CombinedText
stringlengths 8
3.42M
|
|---|
/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE, See the above copyright notices for more information.
=========================================================================*/
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#ifdef __BORLANDC__
#define ITK_LEAN_AND_MEAN
#endif
#include "otbImage.h"
#include "otbVectorImage.h"
#include "otbImageFileReader.h"
#include "otbStreamingImageFileWriter.h"
#include "otbVectorRescaleIntensityImageFilter.h"
#include "otbCommandLineArgumentParser.h"
#include "itkCastImageFilter.h"
#include "otbStandardFilterWatcher.h"
#include "otbStandardWriterWatcher.h"
template<typename OutputPixelType>
int generic_main_convert(otb::CommandLineArgumentParseResult* parseResult)
{
typedef otb::VectorImage<double, 2> InputImageType;
typedef otb::VectorImage<OutputPixelType, 2> OutputImageType;
typedef otb::StreamingImageFileWriter<OutputImageType> WriterType;
typename WriterType::Pointer writer=WriterType::New();
writer->SetFileName(parseResult->GetOutputImage().c_str());
if (parseResult->IsOptionPresent("--UseRescale"))
{
typedef otb::ImageFileReader<InputImageType> ReaderType;
typename ReaderType::Pointer reader=ReaderType::New();
reader->SetFileName(parseResult->GetInputImage().c_str());
reader->UpdateOutputInformation();
typedef otb::VectorRescaleIntensityImageFilter<InputImageType, OutputImageType> RescalerType;
typename OutputImageType::PixelType minimum;
typename OutputImageType::PixelType maximum;
minimum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel());
maximum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel());
minimum.Fill(itk::NumericTraits<OutputPixelType>::min());
maximum.Fill(itk::NumericTraits<OutputPixelType>::max());
typename RescalerType::Pointer rescaler=RescalerType::New();
rescaler->SetOutputMinimum(minimum);
rescaler->SetOutputMaximum(maximum);
rescaler->SetInput(reader->GetOutput());
writer->SetInput(rescaler->GetOutput());
otb::StandardWriterWatcher watcher(writer,rescaler,"Conversion");
writer->Update();
}
else
{
typedef otb::ImageFileReader<OutputImageType> ReaderType;
typename ReaderType::Pointer reader=ReaderType::New();
reader->SetFileName(parseResult->GetInputImage().c_str());
otb::StandardFilterWatcher watcher(writer,"Conversion");
writer->SetInput(reader->GetOutput());
writer->Update();
}
return EXIT_SUCCESS;
}
int main(int argc, char * argv[])
{
try
{
// Parse command line parameters
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
parser->SetProgramDescription("Convert an image to a different format, eventually rescaling the data and/or changing the pixel type");
parser->AddInputImage();
parser->AddOutputImage();
parser->AddOption("--OutputPixelType","OutputPixelType: unsigned char (1), short int (2), int (3), float (4), double (5), unsigned short int (12), unsigned int (13); default 1","-t", 1, false);
parser->AddOption("--UseRescale", "Rescale value between output type min and max","-r", 0, false);
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
try
{
parser->ParseCommandLine(argc,argv,parseResult);
}
catch ( itk::ExceptionObject & err )
{
std::string descriptionException = err.GetDescription();
if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos)
{
std::cout << "WARNING : output file pixels are converted in 'unsigned char'" << std::endl;
return EXIT_SUCCESS;
}
if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos)
{
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
unsigned int type=1;
if (parseResult->IsOptionPresent("--OutputPixelType"))
{
type=parseResult->GetParameterUInt("--OutputPixelType");
}
switch (type)
{
case 1:
generic_main_convert<unsigned char>(parseResult);
break;
case 2:
generic_main_convert<short int>(parseResult);
break;
case 3:
generic_main_convert<int>(parseResult);
break;
case 4:
generic_main_convert<float>(parseResult);
break;
case 5:
generic_main_convert<double>(parseResult);
break;
case 12:
generic_main_convert<unsigned short int>(parseResult);
break;
case 13:
generic_main_convert<unsigned int>(parseResult);
break;
default:
generic_main_convert<unsigned char>(parseResult);
break;
}
}
catch ( itk::ExceptionObject & err )
{
std::cout << "Exception itk::ExceptionObject raised !" << std::endl;
std::cout << err << std::endl;
return EXIT_FAILURE;
}
catch ( std::bad_alloc & err )
{
std::cout << "Exception bad_alloc : "<<(char*)err.what()<< std::endl;
return EXIT_FAILURE;
}
catch ( ... )
{
std::cout << "Unknow exception raised !" << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
DOC: fix copyright and doc
/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif
#ifdef __BORLANDC__
#define ITK_LEAN_AND_MEAN
#endif
#include "otbImage.h"
#include "otbVectorImage.h"
#include "otbImageFileReader.h"
#include "otbStreamingImageFileWriter.h"
#include "otbVectorRescaleIntensityImageFilter.h"
#include "otbCommandLineArgumentParser.h"
#include "itkCastImageFilter.h"
#include "otbStandardFilterWatcher.h"
#include "otbStandardWriterWatcher.h"
template<typename OutputPixelType>
int generic_main_convert(otb::CommandLineArgumentParseResult* parseResult)
{
typedef otb::VectorImage<double, 2> InputImageType;
typedef otb::VectorImage<OutputPixelType, 2> OutputImageType;
typedef otb::StreamingImageFileWriter<OutputImageType> WriterType;
typename WriterType::Pointer writer=WriterType::New();
writer->SetFileName(parseResult->GetOutputImage().c_str());
if (parseResult->IsOptionPresent("--UseRescale"))
{
typedef otb::ImageFileReader<InputImageType> ReaderType;
typename ReaderType::Pointer reader=ReaderType::New();
reader->SetFileName(parseResult->GetInputImage().c_str());
reader->UpdateOutputInformation();
typedef otb::VectorRescaleIntensityImageFilter<InputImageType, OutputImageType> RescalerType;
typename OutputImageType::PixelType minimum;
typename OutputImageType::PixelType maximum;
minimum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel());
maximum.SetSize(reader->GetOutput()->GetNumberOfComponentsPerPixel());
minimum.Fill(itk::NumericTraits<OutputPixelType>::min());
maximum.Fill(itk::NumericTraits<OutputPixelType>::max());
typename RescalerType::Pointer rescaler=RescalerType::New();
rescaler->SetOutputMinimum(minimum);
rescaler->SetOutputMaximum(maximum);
rescaler->SetInput(reader->GetOutput());
writer->SetInput(rescaler->GetOutput());
otb::StandardWriterWatcher watcher(writer,rescaler,"Conversion");
writer->Update();
}
else
{
typedef otb::ImageFileReader<OutputImageType> ReaderType;
typename ReaderType::Pointer reader=ReaderType::New();
reader->SetFileName(parseResult->GetInputImage().c_str());
otb::StandardFilterWatcher watcher(writer,"Conversion");
writer->SetInput(reader->GetOutput());
writer->Update();
}
return EXIT_SUCCESS;
}
int main(int argc, char * argv[])
{
try
{
// Parse command line parameters
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
parser->SetProgramDescription("Convert an image to a different format, eventually rescaling the data and/or changing the pixel type");
parser->AddInputImage();
parser->AddOutputImage();
parser->AddOption("--OutputPixelType","OutputPixelType: unsigned char (1), short int (2), int (3), float (4), double (5), unsigned short int (12), unsigned int (13); default 1","-t", 1, false);
parser->AddOption("--UseRescale", "Rescale value between output type min and max","-r", 0, false);
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
try
{
parser->ParseCommandLine(argc,argv,parseResult);
}
catch ( itk::ExceptionObject & err )
{
std::string descriptionException = err.GetDescription();
if (descriptionException.find("ParseCommandLine(): Help Parser") != std::string::npos)
{
std::cout << "WARNING : output file pixels are converted in 'unsigned char'" << std::endl;
return EXIT_SUCCESS;
}
if (descriptionException.find("ParseCommandLine(): Version Parser") != std::string::npos)
{
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
unsigned int type=1;
if (parseResult->IsOptionPresent("--OutputPixelType"))
{
type=parseResult->GetParameterUInt("--OutputPixelType");
}
switch (type)
{
case 1:
generic_main_convert<unsigned char>(parseResult);
break;
case 2:
generic_main_convert<short int>(parseResult);
break;
case 3:
generic_main_convert<int>(parseResult);
break;
case 4:
generic_main_convert<float>(parseResult);
break;
case 5:
generic_main_convert<double>(parseResult);
break;
case 12:
generic_main_convert<unsigned short int>(parseResult);
break;
case 13:
generic_main_convert<unsigned int>(parseResult);
break;
default:
generic_main_convert<unsigned char>(parseResult);
break;
}
}
catch ( itk::ExceptionObject & err )
{
std::cout << "Exception itk::ExceptionObject raised !" << std::endl;
std::cout << err << std::endl;
return EXIT_FAILURE;
}
catch ( std::bad_alloc & err )
{
std::cout << "Exception bad_alloc : "<<(char*)err.what()<< std::endl;
return EXIT_FAILURE;
}
catch ( ... )
{
std::cout << "Unknow exception raised !" << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
|
/******************************************************************************
* SOFA, Simulation Open-Framework Architecture, version 1.0 RC 1 *
* (c) 2006-2011 INRIA, USTL, UJF, CNRS, MGH *
* *
* This program is free software; you can redistribute it and/or modify it *
* under the terms of the GNU General Public License as published by the Free *
* Software Foundation; either version 2 of the License, or (at your option) *
* any later version. *
* *
* This program is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for *
* more details. *
* *
* You should have received a copy of the GNU General Public License along *
* with this program; if not, write to the Free Software Foundation, Inc., 51 *
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
*******************************************************************************
* SOFA :: Applications *
* *
* Authors: The SOFA Team and external contributors (see Authors.txt) *
* *
* Contact information: contact@sofa-framework.org *
******************************************************************************/
#include <iostream>
#include <sstream>
#include <fstream>
#include <sofa/helper/ArgumentParser.h>
#include <sofa/helper/UnitTest.h>
#include <sofa/helper/vector_algebra.h>
#include <sofa/helper/vector.h>
#include <sofa/helper/BackTrace.h>
#include <sofa/helper/system/PluginManager.h>
//#include <sofa/simulation/tree/TreeSimulation.h>
#ifdef SOFA_HAVE_DAG
#include <sofa/simulation/graph/DAGSimulation.h>
#endif
#ifdef SOFA_HAVE_BGL
#include <sofa/simulation/bgl/BglSimulation.h>
#endif
#include <sofa/simulation/common/Node.h>
#include <sofa/simulation/common/xml/initXml.h>
#include <sofa/gui/GUIManager.h>
#include <sofa/gui/Main.h>
#include <sofa/helper/system/FileRepository.h>
#include <sofa/component/init.h>
#include <sofa/component/mapping/SubsetMultiMapping.h>
#include <sofa/component/topology/MeshTopology.h>
#include <sofa/component/topology/EdgeSetTopologyContainer.h>
#include <sofa/component/collision/SphereModel.h>
#include <sofa/component/topology/CubeTopology.h>
#include <sofa/component/visualmodel/VisualStyle.h>
#include <sofa/component/odesolver/EulerImplicitSolver.h>
#include <sofa/component/linearsolver/CGLinearSolver.h>
//Using double by default, if you have SOFA_FLOAT in use in you sofa-default.cfg, then it will be FLOAT.
#include <sofa/component/typedef/Sofa_typedef.h>
#include "../../../applications/tutorials/objectCreator/ObjectCreator.h"
#include <plugins/Compliant/Compliant_lib/ComplianceSolver.h>
#include <plugins/Compliant/Compliant_lib/UniformCompliance.h>
#include <plugins/Compliant/Compliant_lib/CompliantAttachButtonSetting.h>
using sofa::component::configurationsetting::CompliantAttachButtonSetting;
#include <plugins/Flexible/deformationMapping/ExtensionMapping.h>
#include <plugins/Flexible/deformationMapping/DistanceMapping.h>
using namespace sofa;
using namespace sofa::helper;
using namespace sofa::simulation;
using namespace sofa::core::objectmodel;
using namespace sofa::component::container;
using namespace sofa::component::topology;
using namespace sofa::component::collision;
using namespace sofa::component::visualmodel;
using namespace sofa::component::mapping;
using namespace sofa::component::forcefield;
typedef SReal Scalar;
typedef Vec<3,SReal> Vec3;
typedef Vec<1,SReal> Vec1;
typedef ExtensionMapping<MechanicalObject3::DataTypes, MechanicalObject1::DataTypes> ExtensionMapping31;
typedef DistanceMapping<MechanicalObject3::DataTypes, MechanicalObject1::DataTypes> DistanceMapping31;
typedef UniformCompliance<Vec1Types> UniformCompliance1;
typedef component::odesolver::ComplianceSolver ComplianceSolver;
typedef component::odesolver::EulerImplicitSolver EulerImplicitSolver;
typedef component::linearsolver::CGLinearSolver<component::linearsolver::GraphScatteredMatrix, component::linearsolver::GraphScatteredVector> CGLinearSolver;
bool startAnim = true;
bool verbose = false;
std::string simulationType = "bgl";
SReal complianceValue = 0.1;
SReal dampingRatio = 0.1;
Vec3 gravity(0,-1,0);
SReal dt = 0.01;
/// Create a compliant string
simulation::Node::SPtr createCompliantString(simulation::Node::SPtr parent, Vec3 startPoint, Vec3 endPoint, unsigned numParticles, double totalMass, double complianceValue=0, double dampingRatio=0 )
{
static unsigned numObject = 1;
std::ostringstream oss;
oss << "string_" << numObject++;
SReal totalLength = (endPoint-startPoint).norm();
//--------
Node::SPtr string_node = parent->createChild(oss.str());
MechanicalObject3::SPtr DOF = New<MechanicalObject3>();
string_node->addObject(DOF);
DOF->setName(oss.str()+"_DOF");
UniformMass3::SPtr mass = New<UniformMass3>();
string_node->addObject(mass);
mass->setName(oss.str()+"_mass");
mass->mass.setValue( totalMass/numParticles );
//--------
Node::SPtr extension_node = string_node->createChild( oss.str()+"_ExtensionNode");
MechanicalObject1::SPtr extensions = New<MechanicalObject1>();
extension_node->addObject(extensions);
EdgeSetTopologyContainer::SPtr edgeSet = New<EdgeSetTopologyContainer>();
extension_node->addObject(edgeSet);
ExtensionMapping31::SPtr extensionMapping = New<ExtensionMapping31>();
extensionMapping->setModels(DOF.get(),extensions.get());
extension_node->addObject( extensionMapping );
extensionMapping->setName(oss.str()+"_ExtensionMapping");
extensionMapping->setModels( DOF.get(), extensions.get() );
UniformCompliance1::SPtr compliance = New<UniformCompliance1>();
extension_node->addObject(compliance);
compliance->setName(oss.str()+"_compliance");
compliance->compliance.setValue(complianceValue);
compliance->dampingRatio.setValue(dampingRatio);
//--------
// create the particles
DOF->resize(numParticles);
MechanicalObject3::WriteVecCoord x = DOF->writePositions();
helper::vector<SReal> restLengths;
for( unsigned i=0; i<numParticles; i++ )
{
double alpha = (double)i/(numParticles-1);
x[i] = startPoint * (1-alpha) + endPoint * alpha;
if(i>0)
{
edgeSet->addEdge(i-1,i);
restLengths.push_back( totalLength/(numParticles-1) );
}
}
extensionMapping->f_restLengths.setValue( restLengths );
// {
// //-------- fix a particle
// Node::SPtr fixNode = string_node->createChild("fixNode");
// MechanicalObject1::SPtr extensions = New<MechanicalObject1>();
// fixNode->addObject(extensions);
// DistanceMapping31::SPtr distanceMapping = New<DistanceMapping31>();
// distanceMapping->setModels(DOF.get(),extensions.get());
// fixNode->addObject( distanceMapping );
// distanceMapping->setName("fix_distanceMapping");
// distanceMapping->setModels( DOF.get(), extensions.get() );
// distanceMapping->createTarget( numParticles-1, endPoint, 0.0 );
// UniformCompliance1::SPtr compliance = New<UniformCompliance1>();
// fixNode->addObject(compliance);
// compliance->setName("fix_compliance");
// compliance->compliance.setValue(complianceValue);
// compliance->dampingRatio.setValue(dampingRatio);
// }
return string_node;
}
/// Create the compliant string composed of three parts
simulation::Node::SPtr createCompliantScene()
{
// The graph root node
Node::SPtr root = simulation::getSimulation()->createNewGraph("root");
root->setGravity( Coord3(0,-1,0) );
root->setAnimate(false);
root->setDt(0.01);
addVisualStyle(root)->setShowVisual(false).setShowCollision(false).setShowMapping(true).setShowBehavior(true);
// CompliantAttachButtonSetting::SPtr buttonSetting = New<CompliantAttachButtonSetting>();
// root->addObject(buttonSetting);
// sofa::helper::OptionsGroup b=buttonSetting->button.getValue();
// b.setSelectedItem("Left");
// buttonSetting->button.setValue(b);
Node::SPtr simulatedScene = root->createChild("simulatedScene");
ComplianceSolver::SPtr complianceSolver = New<ComplianceSolver>();
simulatedScene->addObject( complianceSolver );
complianceSolver->implicitVelocity.setValue(1.0);
complianceSolver->implicitPosition.setValue(1.0);
complianceSolver->verbose.setValue(verbose);
// ======== first string
unsigned n1 = 2;
Node::SPtr string1 = createCompliantString( simulatedScene, Vec3(0,0,0), Vec3(1,0,0), n1, 1.0*n1, complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed1 = New<FixedConstraint3>();
string1->addObject( fixed1 );
// ======== second string
unsigned n2 = 2;
Node::SPtr string2 = createCompliantString( simulatedScene, Vec3(3,0,0), Vec3(2,0,0), n2, 1.0*n2, complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed2 = New<FixedConstraint3>();
string2->addObject( fixed2 );
// ======== Node with multiple parents to create an interaction using a MultiMapping
Node::SPtr commonChild = string1->createChild("commonChild");
string2->addChild(commonChild);
MechanicalObject3::SPtr mappedDOF = New<MechanicalObject3>(); // to contain particles from the two strings
commonChild->addObject(mappedDOF);
SubsetMultiMapping3_to_3::SPtr multimapping = New<SubsetMultiMapping3_to_3>();
multimapping->setName("InteractionMultiMapping");
multimapping->addInputModel( string1->getMechanicalState() );
multimapping->addInputModel( string2->getMechanicalState() );
multimapping->addOutputModel( mappedDOF.get() );
multimapping->addPoint( string1->getMechanicalState(), n1-1 );
multimapping->addPoint( string2->getMechanicalState(), n2-1 );
commonChild->addObject(multimapping);
// Node to handle the extension of the interaction link
Node::SPtr extension_node = commonChild->createChild("InteractionExtensionNode");
MechanicalObject1::SPtr extensions = New<MechanicalObject1>();
extension_node->addObject(extensions);
EdgeSetTopologyContainer::SPtr edgeSet = New<EdgeSetTopologyContainer>();
extension_node->addObject(edgeSet);
edgeSet->addEdge(0,1);
ExtensionMapping31::SPtr extensionMapping = New<ExtensionMapping31>();
extensionMapping->setModels(mappedDOF.get(),extensions.get());
extension_node->addObject( extensionMapping );
extensionMapping->setName("InteractionExtension_mapping");
UniformCompliance1::SPtr compliance = New<UniformCompliance1>();
extension_node->addObject(compliance);
compliance->compliance.setName("connectionCompliance");
compliance->compliance.setValue(complianceValue);
compliance->dampingRatio.setValue(dampingRatio);
return root;
}
/// Create a stiff string
simulation::Node::SPtr createStiffString(simulation::Node::SPtr parent, Vec3 startPoint, Vec3 endPoint, unsigned numParticles, double totalMass, double stiffnessValue=1.0, double dampingRatio=0 )
{
static unsigned numObject = 1;
std::ostringstream oss;
oss << "string_" << numObject++;
SReal totalLength = (endPoint-startPoint).norm();
//--------
Node::SPtr string_node = parent->createChild(oss.str());
MechanicalObject3::SPtr DOF = New<MechanicalObject3>();
string_node->addObject(DOF);
DOF->setName(oss.str()+"_DOF");
UniformMass3::SPtr mass = New<UniformMass3>();
string_node->addObject(mass);
mass->setName(oss.str()+"_mass");
mass->mass.setValue( totalMass/numParticles );
StiffSpringForceField3::SPtr spring = New<StiffSpringForceField3>();
string_node->addObject(spring);
spring->setName(oss.str()+"_spring");
//--------
// create the particles and the springs
DOF->resize(numParticles);
MechanicalObject3::WriteVecCoord x = DOF->writePositions();
for( unsigned i=0; i<numParticles; i++ )
{
double alpha = (double)i/(numParticles-1);
x[i] = startPoint * (1-alpha) + endPoint * alpha;
if(i>0)
{
spring->addSpring(i-1,i,stiffnessValue,dampingRatio,totalLength/(numParticles-1));
}
}
return string_node;
}
/// Create the stiff string composed of three parts
simulation::Node::SPtr createStiffScene()
{
// The graph root node
Node::SPtr root = simulation::getSimulation()->createNewGraph("root");
root->setGravity( Coord3(0,-1,0) );
root->setAnimate(false);
root->setDt(0.01);
addVisualStyle(root)->setShowVisual(false).setShowCollision(false).setShowMapping(true).setShowBehavior(true);
Node::SPtr simulatedScene = root->createChild("simulatedScene");
EulerImplicitSolver::SPtr eulerImplicitSolver = New<EulerImplicitSolver>();
simulatedScene->addObject( eulerImplicitSolver );
CGLinearSolver::SPtr cgLinearSolver = New<CGLinearSolver>();
simulatedScene->addObject(cgLinearSolver);
// ======== first string
unsigned n1 = 3;
Node::SPtr string1 = createStiffString( simulatedScene, Vec3(0,0,0), Vec3(1,0,0), n1, 1.0*n1, 1/complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed1 = New<FixedConstraint3>();
string1->addObject( fixed1 );
// ======== second string
unsigned n2 = 3;
Node::SPtr string2 = createStiffString( simulatedScene, Vec3(3,0,0), Vec3(2,0,0), n2, 1.0*n2, 1/complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed2 = New<FixedConstraint3>();
string2->addObject( fixed2 );
// ======== Node with multiple parents to create an interaction using a MultiMapping
Node::SPtr commonChild = string1->createChild("commonChild");
string2->addChild(commonChild);
MechanicalObject3::SPtr mappedDOF = New<MechanicalObject3>(); // to contain particles from the two strings
commonChild->addObject(mappedDOF);
SubsetMultiMapping3_to_3::SPtr multimapping = New<SubsetMultiMapping3_to_3>();
multimapping->setName("InteractionMultiMapping");
multimapping->addInputModel( string1->getMechanicalState() );
multimapping->addInputModel( string2->getMechanicalState() );
multimapping->addOutputModel( mappedDOF.get() );
multimapping->addPoint( string1->getMechanicalState(), n1-1 );
multimapping->addPoint( string2->getMechanicalState(), n2-1 );
commonChild->addObject(multimapping);
StiffSpringForceField3::SPtr spring = New<StiffSpringForceField3>();
commonChild->addObject(spring);
spring->setName("InteractionSpring");
spring->addSpring(0,1,1/complianceValue,dampingRatio,1.0);
return root;
}
int main(int argc, char** argv)
{
sofa::helper::BackTrace::autodump();
sofa::core::ExecParams::defaultInstance()->setAspectID(0);
sofa::helper::parse("This is a SOFA application. Here are the command line arguments")
.option(&startAnim,'a',"start","start the animation loop")
.option(&simulationType,'s',"simu","select the type of simulation (bgl, tree)")
.option(&verbose,'v',"verbose","print debug info")
(argc,argv);
glutInit(&argc,argv);
//#ifdef SOFA_DEV
// if (simulationType == "bgl")
// sofa::simulation::setSimulation(new sofa::simulation::bgl::BglSimulation());
// else
//#endif
// sofa::simulation::setSimulation(new sofa::simulation::tree::TreeSimulation());
#ifdef SOFA_HAVE_DAG
sofa::simulation::setSimulation(new sofa::simulation::graph::DAGSimulation());
#endif
sofa::component::init();
#ifdef SOFA_GPU_CUDA
#ifdef WIN32
#ifdef NDEBUG
std::string name("sofagpucuda_1_0.dll");
#else
std::string name("sofagpucuda_1_0d.dll");
#endif
sofa::helper::system::DynamicLibrary::load(name);
#endif
#endif
sofa::gui::initMain();
if (int err = sofa::gui::GUIManager::Init(argv[0],"")) return err;
if (int err=sofa::gui::GUIManager::createGUI(NULL)) return err;
sofa::gui::GUIManager::SetDimension(800,600);
//=================================================
sofa::simulation::Node::SPtr groot = createStiffScene();
// sofa::simulation::Node::SPtr groot = createCompliantScene();
//=================================================
sofa::simulation::getSimulation()->init(groot.get());
sofa::gui::GUIManager::SetScene(groot);
// Run the main loop
if (int err = sofa::gui::GUIManager::MainLoop(groot))
return err;
sofa::simulation::getSimulation()->unload(groot);
sofa::gui::GUIManager::closeGUI();
return 0;
}
r8961/sofa : Compliant_run: fixed compilation
Former-commit-id: d02c0694c250c918ad52010ee3a0be6e5c23efc2
/******************************************************************************
* SOFA, Simulation Open-Framework Architecture, version 1.0 RC 1 *
* (c) 2006-2011 INRIA, USTL, UJF, CNRS, MGH *
* *
* This program is free software; you can redistribute it and/or modify it *
* under the terms of the GNU General Public License as published by the Free *
* Software Foundation; either version 2 of the License, or (at your option) *
* any later version. *
* *
* This program is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for *
* more details. *
* *
* You should have received a copy of the GNU General Public License along *
* with this program; if not, write to the Free Software Foundation, Inc., 51 *
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
*******************************************************************************
* SOFA :: Applications *
* *
* Authors: The SOFA Team and external contributors (see Authors.txt) *
* *
* Contact information: contact@sofa-framework.org *
******************************************************************************/
#include <iostream>
#include <sstream>
#include <fstream>
#include <sofa/helper/ArgumentParser.h>
#include <sofa/helper/UnitTest.h>
#include <sofa/helper/vector_algebra.h>
#include <sofa/helper/vector.h>
#include <sofa/helper/BackTrace.h>
#include <sofa/helper/system/PluginManager.h>
//#include <sofa/simulation/tree/TreeSimulation.h>
#ifdef SOFA_HAVE_DAG
#include <sofa/simulation/graph/DAGSimulation.h>
#endif
#ifdef SOFA_HAVE_BGL
#include <sofa/simulation/bgl/BglSimulation.h>
#endif
#include <sofa/simulation/common/Node.h>
#include <sofa/simulation/common/xml/initXml.h>
#include <sofa/gui/GUIManager.h>
#include <sofa/gui/Main.h>
#include <sofa/helper/system/FileRepository.h>
#include <sofa/component/init.h>
#include <sofa/component/mapping/SubsetMultiMapping.h>
#include <sofa/component/topology/MeshTopology.h>
#include <sofa/component/topology/EdgeSetTopologyContainer.h>
#include <sofa/component/collision/SphereModel.h>
#include <sofa/component/topology/CubeTopology.h>
#include <sofa/component/visualmodel/VisualStyle.h>
#include <sofa/component/odesolver/EulerImplicitSolver.h>
#include <sofa/component/linearsolver/CGLinearSolver.h>
//Using double by default, if you have SOFA_FLOAT in use in you sofa-default.cfg, then it will be FLOAT.
#include <sofa/component/typedef/Sofa_typedef.h>
#include "../../../applications/tutorials/objectCreator/ObjectCreator.h"
#include <plugins/Compliant/Compliant_lib/ComplianceSolver.h>
#include <plugins/Compliant/Compliant_lib/UniformCompliance.h>
#include <plugins/Compliant/Compliant_lib/CompliantAttachButtonSetting.h>
using sofa::component::configurationsetting::CompliantAttachButtonSetting;
#include <plugins/Flexible/deformationMapping/ExtensionMapping.h>
#include <plugins/Flexible/deformationMapping/DistanceMapping.h>
#include <sofa/simulation/common/Simulation.h>
using namespace sofa;
using namespace sofa::helper;
using namespace sofa::simulation;
using namespace sofa::core::objectmodel;
using namespace sofa::component::container;
using namespace sofa::component::topology;
using namespace sofa::component::collision;
using namespace sofa::component::visualmodel;
using namespace sofa::component::mapping;
using namespace sofa::component::forcefield;
typedef SReal Scalar;
typedef Vec<3,SReal> Vec3;
typedef Vec<1,SReal> Vec1;
typedef ExtensionMapping<MechanicalObject3::DataTypes, MechanicalObject1::DataTypes> ExtensionMapping31;
typedef DistanceMapping<MechanicalObject3::DataTypes, MechanicalObject1::DataTypes> DistanceMapping31;
typedef UniformCompliance<Vec1Types> UniformCompliance1;
typedef component::odesolver::ComplianceSolver ComplianceSolver;
typedef component::odesolver::EulerImplicitSolver EulerImplicitSolver;
typedef component::linearsolver::CGLinearSolver<component::linearsolver::GraphScatteredMatrix, component::linearsolver::GraphScatteredVector> CGLinearSolver;
bool startAnim = true;
bool verbose = false;
std::string simulationType = "bgl";
SReal complianceValue = 0.1;
SReal dampingRatio = 0.1;
Vec3 gravity(0,-1,0);
SReal dt = 0.01;
/// Create a compliant string
simulation::Node::SPtr createCompliantString(simulation::Node::SPtr parent, Vec3 startPoint, Vec3 endPoint, unsigned numParticles, double totalMass, double complianceValue=0, double dampingRatio=0 )
{
static unsigned numObject = 1;
std::ostringstream oss;
oss << "string_" << numObject++;
SReal totalLength = (endPoint-startPoint).norm();
//--------
Node::SPtr string_node = parent->createChild(oss.str());
MechanicalObject3::SPtr DOF = New<MechanicalObject3>();
string_node->addObject(DOF);
DOF->setName(oss.str()+"_DOF");
UniformMass3::SPtr mass = New<UniformMass3>();
string_node->addObject(mass);
mass->setName(oss.str()+"_mass");
mass->mass.setValue( totalMass/numParticles );
//--------
Node::SPtr extension_node = string_node->createChild( oss.str()+"_ExtensionNode");
MechanicalObject1::SPtr extensions = New<MechanicalObject1>();
extension_node->addObject(extensions);
EdgeSetTopologyContainer::SPtr edgeSet = New<EdgeSetTopologyContainer>();
extension_node->addObject(edgeSet);
ExtensionMapping31::SPtr extensionMapping = New<ExtensionMapping31>();
extensionMapping->setModels(DOF.get(),extensions.get());
extension_node->addObject( extensionMapping );
extensionMapping->setName(oss.str()+"_ExtensionMapping");
extensionMapping->setModels( DOF.get(), extensions.get() );
UniformCompliance1::SPtr compliance = New<UniformCompliance1>();
extension_node->addObject(compliance);
compliance->setName(oss.str()+"_compliance");
compliance->compliance.setValue(complianceValue);
compliance->dampingRatio.setValue(dampingRatio);
//--------
// create the particles
DOF->resize(numParticles);
MechanicalObject3::WriteVecCoord x = DOF->writePositions();
helper::vector<SReal> restLengths;
for( unsigned i=0; i<numParticles; i++ )
{
double alpha = (double)i/(numParticles-1);
x[i] = startPoint * (1-alpha) + endPoint * alpha;
if(i>0)
{
edgeSet->addEdge(i-1,i);
restLengths.push_back( totalLength/(numParticles-1) );
}
}
extensionMapping->f_restLengths.setValue( restLengths );
// {
// //-------- fix a particle
// Node::SPtr fixNode = string_node->createChild("fixNode");
// MechanicalObject1::SPtr extensions = New<MechanicalObject1>();
// fixNode->addObject(extensions);
// DistanceMapping31::SPtr distanceMapping = New<DistanceMapping31>();
// distanceMapping->setModels(DOF.get(),extensions.get());
// fixNode->addObject( distanceMapping );
// distanceMapping->setName("fix_distanceMapping");
// distanceMapping->setModels( DOF.get(), extensions.get() );
// distanceMapping->createTarget( numParticles-1, endPoint, 0.0 );
// UniformCompliance1::SPtr compliance = New<UniformCompliance1>();
// fixNode->addObject(compliance);
// compliance->setName("fix_compliance");
// compliance->compliance.setValue(complianceValue);
// compliance->dampingRatio.setValue(dampingRatio);
// }
return string_node;
}
/// Create the compliant string composed of three parts
simulation::Node::SPtr createCompliantScene()
{
// The graph root node
Node::SPtr root = simulation::getSimulation()->createNewGraph("root");
root->setGravity( Coord3(0,-1,0) );
root->setAnimate(false);
root->setDt(0.01);
addVisualStyle(root)->setShowVisual(false).setShowCollision(false).setShowMapping(true).setShowBehavior(true);
// CompliantAttachButtonSetting::SPtr buttonSetting = New<CompliantAttachButtonSetting>();
// root->addObject(buttonSetting);
// sofa::helper::OptionsGroup b=buttonSetting->button.getValue();
// b.setSelectedItem("Left");
// buttonSetting->button.setValue(b);
Node::SPtr simulatedScene = root->createChild("simulatedScene");
ComplianceSolver::SPtr complianceSolver = New<ComplianceSolver>();
simulatedScene->addObject( complianceSolver );
complianceSolver->implicitVelocity.setValue(1.0);
complianceSolver->implicitPosition.setValue(1.0);
complianceSolver->verbose.setValue(verbose);
// ======== first string
unsigned n1 = 2;
Node::SPtr string1 = createCompliantString( simulatedScene, Vec3(0,0,0), Vec3(1,0,0), n1, 1.0*n1, complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed1 = New<FixedConstraint3>();
string1->addObject( fixed1 );
// ======== second string
unsigned n2 = 2;
Node::SPtr string2 = createCompliantString( simulatedScene, Vec3(3,0,0), Vec3(2,0,0), n2, 1.0*n2, complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed2 = New<FixedConstraint3>();
string2->addObject( fixed2 );
// ======== Node with multiple parents to create an interaction using a MultiMapping
Node::SPtr commonChild = string1->createChild("commonChild");
string2->addChild(commonChild);
MechanicalObject3::SPtr mappedDOF = New<MechanicalObject3>(); // to contain particles from the two strings
commonChild->addObject(mappedDOF);
SubsetMultiMapping3_to_3::SPtr multimapping = New<SubsetMultiMapping3_to_3>();
multimapping->setName("InteractionMultiMapping");
multimapping->addInputModel( string1->getMechanicalState() );
multimapping->addInputModel( string2->getMechanicalState() );
multimapping->addOutputModel( mappedDOF.get() );
multimapping->addPoint( string1->getMechanicalState(), n1-1 );
multimapping->addPoint( string2->getMechanicalState(), n2-1 );
commonChild->addObject(multimapping);
// Node to handle the extension of the interaction link
Node::SPtr extension_node = commonChild->createChild("InteractionExtensionNode");
MechanicalObject1::SPtr extensions = New<MechanicalObject1>();
extension_node->addObject(extensions);
EdgeSetTopologyContainer::SPtr edgeSet = New<EdgeSetTopologyContainer>();
extension_node->addObject(edgeSet);
edgeSet->addEdge(0,1);
ExtensionMapping31::SPtr extensionMapping = New<ExtensionMapping31>();
extensionMapping->setModels(mappedDOF.get(),extensions.get());
extension_node->addObject( extensionMapping );
extensionMapping->setName("InteractionExtension_mapping");
UniformCompliance1::SPtr compliance = New<UniformCompliance1>();
extension_node->addObject(compliance);
compliance->compliance.setName("connectionCompliance");
compliance->compliance.setValue(complianceValue);
compliance->dampingRatio.setValue(dampingRatio);
return root;
}
/// Create a stiff string
simulation::Node::SPtr createStiffString(simulation::Node::SPtr parent, Vec3 startPoint, Vec3 endPoint, unsigned numParticles, double totalMass, double stiffnessValue=1.0, double dampingRatio=0 )
{
static unsigned numObject = 1;
std::ostringstream oss;
oss << "string_" << numObject++;
SReal totalLength = (endPoint-startPoint).norm();
//--------
Node::SPtr string_node = parent->createChild(oss.str());
MechanicalObject3::SPtr DOF = New<MechanicalObject3>();
string_node->addObject(DOF);
DOF->setName(oss.str()+"_DOF");
UniformMass3::SPtr mass = New<UniformMass3>();
string_node->addObject(mass);
mass->setName(oss.str()+"_mass");
mass->mass.setValue( totalMass/numParticles );
StiffSpringForceField3::SPtr spring = New<StiffSpringForceField3>();
string_node->addObject(spring);
spring->setName(oss.str()+"_spring");
//--------
// create the particles and the springs
DOF->resize(numParticles);
MechanicalObject3::WriteVecCoord x = DOF->writePositions();
for( unsigned i=0; i<numParticles; i++ )
{
double alpha = (double)i/(numParticles-1);
x[i] = startPoint * (1-alpha) + endPoint * alpha;
if(i>0)
{
spring->addSpring(i-1,i,stiffnessValue,dampingRatio,totalLength/(numParticles-1));
}
}
return string_node;
}
/// Create the stiff string composed of three parts
simulation::Node::SPtr createStiffScene()
{
// The graph root node
Node::SPtr root = simulation::getSimulation()->createNewGraph("root");
root->setGravity( Coord3(0,-1,0) );
root->setAnimate(false);
root->setDt(0.01);
addVisualStyle(root)->setShowVisual(false).setShowCollision(false).setShowMapping(true).setShowBehavior(true);
Node::SPtr simulatedScene = root->createChild("simulatedScene");
EulerImplicitSolver::SPtr eulerImplicitSolver = New<EulerImplicitSolver>();
simulatedScene->addObject( eulerImplicitSolver );
CGLinearSolver::SPtr cgLinearSolver = New<CGLinearSolver>();
simulatedScene->addObject(cgLinearSolver);
// ======== first string
unsigned n1 = 3;
Node::SPtr string1 = createStiffString( simulatedScene, Vec3(0,0,0), Vec3(1,0,0), n1, 1.0*n1, 1/complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed1 = New<FixedConstraint3>();
string1->addObject( fixed1 );
// ======== second string
unsigned n2 = 3;
Node::SPtr string2 = createStiffString( simulatedScene, Vec3(3,0,0), Vec3(2,0,0), n2, 1.0*n2, 1/complianceValue, dampingRatio );
FixedConstraint3::SPtr fixed2 = New<FixedConstraint3>();
string2->addObject( fixed2 );
// ======== Node with multiple parents to create an interaction using a MultiMapping
Node::SPtr commonChild = string1->createChild("commonChild");
string2->addChild(commonChild);
MechanicalObject3::SPtr mappedDOF = New<MechanicalObject3>(); // to contain particles from the two strings
commonChild->addObject(mappedDOF);
SubsetMultiMapping3_to_3::SPtr multimapping = New<SubsetMultiMapping3_to_3>();
multimapping->setName("InteractionMultiMapping");
multimapping->addInputModel( string1->getMechanicalState() );
multimapping->addInputModel( string2->getMechanicalState() );
multimapping->addOutputModel( mappedDOF.get() );
multimapping->addPoint( string1->getMechanicalState(), n1-1 );
multimapping->addPoint( string2->getMechanicalState(), n2-1 );
commonChild->addObject(multimapping);
StiffSpringForceField3::SPtr spring = New<StiffSpringForceField3>();
commonChild->addObject(spring);
spring->setName("InteractionSpring");
spring->addSpring(0,1,1/complianceValue,dampingRatio,1.0);
return root;
}
int main(int argc, char** argv)
{
sofa::helper::BackTrace::autodump();
sofa::core::ExecParams::defaultInstance()->setAspectID(0);
sofa::helper::parse("This is a SOFA application. Here are the command line arguments")
.option(&startAnim,'a',"start","start the animation loop")
.option(&simulationType,'s',"simu","select the type of simulation (bgl, tree)")
.option(&verbose,'v',"verbose","print debug info")
(argc,argv);
glutInit(&argc,argv);
//#ifdef SOFA_DEV
// if (simulationType == "bgl")
// sofa::simulation::setSimulation(new sofa::simulation::bgl::BglSimulation());
// else
//#endif
// sofa::simulation::setSimulation(new sofa::simulation::tree::TreeSimulation());
#ifdef SOFA_HAVE_DAG
sofa::simulation::setSimulation(new sofa::simulation::graph::DAGSimulation());
#endif
sofa::component::init();
#ifdef SOFA_GPU_CUDA
#ifdef WIN32
#ifdef NDEBUG
std::string name("sofagpucuda_1_0.dll");
#else
std::string name("sofagpucuda_1_0d.dll");
#endif
sofa::helper::system::DynamicLibrary::load(name);
#endif
#endif
sofa::gui::initMain();
if (int err = sofa::gui::GUIManager::Init(argv[0],"")) return err;
if (int err=sofa::gui::GUIManager::createGUI(NULL)) return err;
sofa::gui::GUIManager::SetDimension(800,600);
//=================================================
sofa::simulation::Node::SPtr groot = createStiffScene();
// sofa::simulation::Node::SPtr groot = createCompliantScene();
//=================================================
sofa::simulation::getSimulation()->init(groot.get());
sofa::gui::GUIManager::SetScene(groot);
// Run the main loop
if (int err = sofa::gui::GUIManager::MainLoop(groot))
return err;
sofa::simulation::getSimulation()->unload(groot);
sofa::gui::GUIManager::closeGUI();
return 0;
}
|
/**
* Simple Image Processing Library
* Copyright Erik Smistad 2012
* See LICENSE file for information on use
*/
#ifndef SIPL_TYPES
#define SIPL_TYPES
#include <math.h>
namespace SIPL {
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef struct color_float { float red, blue, green;} color_float ;
typedef struct color_uchar { unsigned char red, blue, green;} color_uchar ;
enum slice_plane {X,Y,Z};
class int2;
// Vector classes
class float2 {
public:
float x,y;
float2() {
this->x = 0.0f;
this->y = 0.0f;
};
float2(float x, float y) {
this->x = x;
this->y = y;
};
float length() const {
return sqrt((float)(x*x+y*y));
};
float2 normalize() const {
float l = this->length();
return float2(x/l,y/l);
};
float distance(float2 &other) const ;
float dot(float2 &other) const ;
float distance(int2 &other) const ;
float dot(int2 &other) const ;
template <class T>
float2 operator+(T v) const {
float2 n;
n.x = this->x + v;
n.y = this->y + v;
return n;
};
template <class T>
float2 operator-(T v) const {
float2 n;
n.x = this->x - v;
n.y = this->y - v;
return n;
};
template <class T>
float2 operator*(T v) const {
float2 n;
n.x = this->x * v;
n.y = this->y * v;
return n;
};
template <class T>
float2 operator/(T v) const {
float2 n;
n.x = this->x / v;
n.y = this->y / v;
return n;
};
};
class int3;
class float3 {
public:
float x,y,z;
float3() {
this->x = 0.0f;
this->y = 0.0f;
this->z = 0.0f;
};
float3(float x, float y, float z) {
this->x = x;
this->y = y;
this->z = z;
};
float length() const {
return sqrt((float)(x*x+y*y+z*z));
};
float3 normalize() {
float l = this->length();
return float3(x / l, y / l, z / l);
};
float distance(float3 &other) const ;
float distance(int3 &other) const ;
float dot(float3 &other) const ;
float dot(int3 &other) const ;
template <class T>
float3 operator+(T v) const {
float3 n;
n.x = this->x + v;
n.y = this->y + v;
n.z = this->z + v;
return n;
};
template <class T>
float3 operator-(T v) const {
float3 n;
n.x = this->x - v;
n.y = this->y - v;
n.z = this->z - v;
return n;
};
template <class T>
float3 operator*(T v) const {
float3 n;
n.x = this->x * v;
n.y = this->y * v;
n.z = this->z * v;
return n;
};
template <class T>
float3 operator/(T v) const {
float3 n;
n.x = this->x / v;
n.y = this->y / v;
n.z = this->z / v;
return n;
};
};
// These are not for images/volumes
class int2 {
public:
int x,y;
int2() {
this->x = 0;
this->y = 0;
};
int2(float x, float y) {
this->x = x;
this->y = y;
};
float length() const {
return sqrt((float)(x*x+y*y));
};
float2 normalize() const {
float l = this->length();
return float2(x / l, y / l);
};
float distance(float2 &other) const ;
float dot(float2 &other) const ;
float distance(int2 &other) const ;
float dot(int2 &other) const ;
template <class T>
int2 operator+(T v) const {
int2 n;
n.x = this->x + v;
n.y = this->y + v;
return n;
};
template <class T>
int2 operator-(T v) const {
int2 n;
n.x = this->x - v;
n.y = this->y - v;
return n;
};
template <class T>
int2 operator*(T v) const {
int2 n;
n.x = this->x * v;
n.y = this->y * v;
return n;
};
template <class T>
int2 operator/(T v) const {
int2 n;
n.x = this->x / v;
n.y = this->y / v;
return n;
};
};
class int3 {
public:
int x,y,z;
int3() {
this->x = 0;
this->y = 0;
this->z = 0;
};
int3(int x, int y, int z) {
this->x = x;
this->y = y;
this->z = z;
};
float length() const {
return sqrt((float)(x*x+y*y+z*z));
};
float3 normalize() const {
float l = this->length();
return float3(x / l, y / l, z / l);
};
float distance(float3 &other) const ;
float distance(int3 &other) const ;
float dot(float3 &other) const ;
float dot(int3 &other) const ;
template <class T>
int3 operator+(T v) const {
int3 n;
n.x = this->x + v;
n.y = this->y + v;
n.z = this->z + v;
return n;
};
template <class T>
int3 operator-(T v) const {
int3 n;
n.x = this->x - v;
n.y = this->y - v;
n.z = this->z - v;
return n;
};
template <class T>
int3 operator*(T v) const {
int3 n;
n.x = this->x * v;
n.y = this->y * v;
n.z = this->z * v;
return n;
};
template <class T>
int3 operator/(T v) const {
int3 n;
n.x = this->x / v;
n.y = this->y / v;
n.z = this->z / v;
return n;
};
};
// float2
template <> inline
float2 float2::operator+(float2 other) const {
float2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
float2 float2::operator+(int2 other) const {
float2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
float2 float2::operator-(float2 other) const {
float2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
float2 float2::operator-(int2 other) const {
float2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
float2 float2::operator*(float2 other) const {
float2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <> inline
float2 float2::operator*(int2 other) const {
float2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <class T>
float2 operator+(T scalar, float2 other) {
return other.operator+(scalar);
}
template <class T>
float2 operator-(T scalar, float2 other) {
return other.operator-(scalar);
}
template <class T>
float2 operator*(T scalar, float2 other) {
return other.operator*(scalar);
}
// float3
template <> inline
float3 float3::operator+(float3 other) const {
float3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
float3 float3::operator+(int3 other) const {
float3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
float3 float3::operator-(float3 other) const {
float3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
float3 float3::operator-(int3 other) const {
float3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
float3 float3::operator*(float3 other) const {
float3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <> inline
float3 float3::operator*(int3 other) const {
float3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <class T>
float3 operator+(T scalar, float3 other) {
return other.operator+(scalar);
}
template <class T>
float3 operator-(T scalar, float3 other) {
return other.operator-(scalar);
}
template <class T>
float3 operator*(T scalar, float3 other) {
return other.operator*(scalar);
}
// int2
template <> inline
int2 int2::operator+(float2 other) const {
int2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
int2 int2::operator+(int2 other) const {
int2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
int2 int2::operator-(float2 other) const {
int2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
int2 int2::operator-(int2 other) const {
int2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
int2 int2::operator*(float2 other) const {
int2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <> inline
int2 int2::operator*(int2 other) const {
int2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <class T>
int2 operator+(T scalar, int2 other) {
return other.operator+(scalar);
}
template <class T>
int2 operator-(T scalar, int2 other) {
return other.operator-(scalar);
}
template <class T>
int2 operator*(T scalar, int2 other) {
return other.operator*(scalar);
}
// float3
template <> inline
int3 int3::operator+(float3 other) const {
int3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
int3 int3::operator+(int3 other) const {
int3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
int3 int3::operator-(float3 other) const {
int3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
int3 int3::operator-(int3 other) const {
int3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
int3 int3::operator*(float3 other) const {
int3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <> inline
int3 int3::operator*(int3 other) const {
int3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <class T>
int3 operator+(T scalar, int3 other) {
return other.operator+(scalar);
}
template <class T>
int3 operator-(T scalar, int3 other) {
return other.operator-(scalar);
}
template <class T>
int3 operator*(T scalar, int3 other) {
return other.operator*(scalar);
}
}; // end SIPL namespace
#endif
added region class
/**
* Simple Image Processing Library
* Copyright Erik Smistad 2012
* See LICENSE file for information on use
*/
#ifndef SIPL_TYPES
#define SIPL_TYPES
#include <math.h>
namespace SIPL {
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef struct color_float { float red, blue, green;} color_float ;
typedef struct color_uchar { unsigned char red, blue, green;} color_uchar ;
enum slice_plane {X,Y,Z};
class int2;
// Vector classes
class float2 {
public:
float x,y;
float2() {
this->x = 0.0f;
this->y = 0.0f;
};
float2(float x, float y) {
this->x = x;
this->y = y;
};
float length() const {
return sqrt((float)(x*x+y*y));
};
float2 normalize() const {
float l = this->length();
return float2(x/l,y/l);
};
float distance(float2 &other) const ;
float dot(float2 &other) const ;
float distance(int2 &other) const ;
float dot(int2 &other) const ;
template <class T>
float2 operator+(T v) const {
float2 n;
n.x = this->x + v;
n.y = this->y + v;
return n;
};
template <class T>
float2 operator-(T v) const {
float2 n;
n.x = this->x - v;
n.y = this->y - v;
return n;
};
template <class T>
float2 operator*(T v) const {
float2 n;
n.x = this->x * v;
n.y = this->y * v;
return n;
};
template <class T>
float2 operator/(T v) const {
float2 n;
n.x = this->x / v;
n.y = this->y / v;
return n;
};
};
class int3;
class float3 {
public:
float x,y,z;
float3() {
this->x = 0.0f;
this->y = 0.0f;
this->z = 0.0f;
};
float3(float x, float y, float z) {
this->x = x;
this->y = y;
this->z = z;
};
float length() const {
return sqrt((float)(x*x+y*y+z*z));
};
float3 normalize() {
float l = this->length();
return float3(x / l, y / l, z / l);
};
float distance(float3 &other) const ;
float distance(int3 &other) const ;
float dot(float3 &other) const ;
float dot(int3 &other) const ;
template <class T>
float3 operator+(T v) const {
float3 n;
n.x = this->x + v;
n.y = this->y + v;
n.z = this->z + v;
return n;
};
template <class T>
float3 operator-(T v) const {
float3 n;
n.x = this->x - v;
n.y = this->y - v;
n.z = this->z - v;
return n;
};
template <class T>
float3 operator*(T v) const {
float3 n;
n.x = this->x * v;
n.y = this->y * v;
n.z = this->z * v;
return n;
};
template <class T>
float3 operator/(T v) const {
float3 n;
n.x = this->x / v;
n.y = this->y / v;
n.z = this->z / v;
return n;
};
};
// These are not for images/volumes
class int2 {
public:
int x,y;
int2() {
this->x = 0;
this->y = 0;
};
int2(float x, float y) {
this->x = x;
this->y = y;
};
float length() const {
return sqrt((float)(x*x+y*y));
};
float2 normalize() const {
float l = this->length();
return float2(x / l, y / l);
};
float distance(float2 &other) const ;
float dot(float2 &other) const ;
float distance(int2 &other) const ;
float dot(int2 &other) const ;
template <class T>
int2 operator+(T v) const {
int2 n;
n.x = this->x + v;
n.y = this->y + v;
return n;
};
template <class T>
int2 operator-(T v) const {
int2 n;
n.x = this->x - v;
n.y = this->y - v;
return n;
};
template <class T>
int2 operator*(T v) const {
int2 n;
n.x = this->x * v;
n.y = this->y * v;
return n;
};
template <class T>
int2 operator/(T v) const {
int2 n;
n.x = this->x / v;
n.y = this->y / v;
return n;
};
};
class int3 {
public:
int x,y,z;
int3() {
this->x = 0;
this->y = 0;
this->z = 0;
};
int3(int x, int y, int z) {
this->x = x;
this->y = y;
this->z = z;
};
float length() const {
return sqrt((float)(x*x+y*y+z*z));
};
float3 normalize() const {
float l = this->length();
return float3(x / l, y / l, z / l);
};
float distance(float3 &other) const ;
float distance(int3 &other) const ;
float dot(float3 &other) const ;
float dot(int3 &other) const ;
template <class T>
int3 operator+(T v) const {
int3 n;
n.x = this->x + v;
n.y = this->y + v;
n.z = this->z + v;
return n;
};
template <class T>
int3 operator-(T v) const {
int3 n;
n.x = this->x - v;
n.y = this->y - v;
n.z = this->z - v;
return n;
};
template <class T>
int3 operator*(T v) const {
int3 n;
n.x = this->x * v;
n.y = this->y * v;
n.z = this->z * v;
return n;
};
template <class T>
int3 operator/(T v) const {
int3 n;
n.x = this->x / v;
n.y = this->y / v;
n.z = this->z / v;
return n;
};
};
class Region {
public:
int3 offset;
int3 size;
Region(int x_size, int y_size);
Region(int x_offset, int y_offset, int x_size, int y_size);
Region(int x_size, int y_size, int z_size);
Region(int x_offset, int y_offset, int z_offset, int x_size, int y_size, int z_size);
};
// float2
template <> inline
float2 float2::operator+(float2 other) const {
float2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
float2 float2::operator+(int2 other) const {
float2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
float2 float2::operator-(float2 other) const {
float2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
float2 float2::operator-(int2 other) const {
float2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
float2 float2::operator*(float2 other) const {
float2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <> inline
float2 float2::operator*(int2 other) const {
float2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <class T>
float2 operator+(T scalar, float2 other) {
return other.operator+(scalar);
}
template <class T>
float2 operator-(T scalar, float2 other) {
return other.operator-(scalar);
}
template <class T>
float2 operator*(T scalar, float2 other) {
return other.operator*(scalar);
}
// float3
template <> inline
float3 float3::operator+(float3 other) const {
float3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
float3 float3::operator+(int3 other) const {
float3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
float3 float3::operator-(float3 other) const {
float3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
float3 float3::operator-(int3 other) const {
float3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
float3 float3::operator*(float3 other) const {
float3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <> inline
float3 float3::operator*(int3 other) const {
float3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <class T>
float3 operator+(T scalar, float3 other) {
return other.operator+(scalar);
}
template <class T>
float3 operator-(T scalar, float3 other) {
return other.operator-(scalar);
}
template <class T>
float3 operator*(T scalar, float3 other) {
return other.operator*(scalar);
}
// int2
template <> inline
int2 int2::operator+(float2 other) const {
int2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
int2 int2::operator+(int2 other) const {
int2 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
return v;
}
template <> inline
int2 int2::operator-(float2 other) const {
int2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
int2 int2::operator-(int2 other) const {
int2 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
return v;
}
template <> inline
int2 int2::operator*(float2 other) const {
int2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <> inline
int2 int2::operator*(int2 other) const {
int2 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
return v;
}
template <class T>
int2 operator+(T scalar, int2 other) {
return other.operator+(scalar);
}
template <class T>
int2 operator-(T scalar, int2 other) {
return other.operator-(scalar);
}
template <class T>
int2 operator*(T scalar, int2 other) {
return other.operator*(scalar);
}
// float3
template <> inline
int3 int3::operator+(float3 other) const {
int3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
int3 int3::operator+(int3 other) const {
int3 v;
v.x = this->x + other.x;
v.y = this->y + other.y;
v.z = this->z + other.z;
return v;
}
template <> inline
int3 int3::operator-(float3 other) const {
int3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
int3 int3::operator-(int3 other) const {
int3 v;
v.x = this->x - other.x;
v.y = this->y - other.y;
v.z = this->z - other.z;
return v;
}
template <> inline
int3 int3::operator*(float3 other) const {
int3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <> inline
int3 int3::operator*(int3 other) const {
int3 v;
v.x = this->x * other.x;
v.y = this->y * other.y;
v.z = this->z * other.z;
return v;
}
template <class T>
int3 operator+(T scalar, int3 other) {
return other.operator+(scalar);
}
template <class T>
int3 operator-(T scalar, int3 other) {
return other.operator-(scalar);
}
template <class T>
int3 operator*(T scalar, int3 other) {
return other.operator*(scalar);
}
}; // end SIPL namespace
#endif
|
/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: uicommanddescription.cxx,v $
*
* $Revision: 1.11 $
*
* last change: $Author: vg $ $Date: 2006-03-14 08:50:51 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
//_________________________________________________________________________________________________________________
// my own includes
//_________________________________________________________________________________________________________________
#ifndef __FRAMEWORK_UIELEMENT_UICOMMANDDESCRPTION_HXX_
#include "uielement/uicommanddescription.hxx"
#endif
#ifndef __FRAMEWORK_THREADHELP_RESETABLEGUARD_HXX_
#include <threadhelp/resetableguard.hxx>
#endif
#ifndef __FRAMEWORK_SERVICES_H_
#include "services.h"
#endif
#include "properties.h"
//_________________________________________________________________________________________________________________
// interface includes
//_________________________________________________________________________________________________________________
#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
#include <com/sun/star/beans/PropertyValue.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_
#include <com/sun/star/beans/XPropertySet.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_
#include <com/sun/star/container/XNameAccess.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_
#include <com/sun/star/container/XNameContainer.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XCONTAINER_HPP_
#include <com/sun/star/container/XContainer.hpp>
#endif
//_________________________________________________________________________________________________________________
// includes of other projects
//_________________________________________________________________________________________________________________
#ifndef _RTL_USTRBUF_HXX_
#include <rtl/ustrbuf.hxx>
#endif
#ifndef _CPPUHELPER_WEAK_HXX_
#include <cppuhelper/weak.hxx>
#endif
#ifndef _UTL_CONFIGMGR_HXX_
#include <unotools/configmgr.hxx>
#endif
#ifndef _STRING_HXX
#include <tools/string.hxx>
#endif
#ifndef _VCL_MNEMONIC_HXX_
#include <vcl/mnemonic.hxx>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _RTL_LOGFILE_HXX_
#include <rtl/logfile.hxx>
#endif
//_________________________________________________________________________________________________________________
// Defines
//_________________________________________________________________________________________________________________
//
using namespace rtl;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::beans;
using namespace com::sun::star::container;
using namespace ::com::sun::star::frame;
//_________________________________________________________________________________________________________________
// Namespace
//_________________________________________________________________________________________________________________
//
struct ModuleToCommands
{
const char* pModuleId;
const char* pCommands;
};
static const char GENERIC_UICOMMANDS[] = "generic";
static const char COMMANDS[] = "Commands";
static const char CONFIGURATION_ROOT_ACCESS[] = "/org.openoffice.Office.UI.";
static const char CONFIGURATION_CMD_ELEMENT_ACCESS[] = "/UserInterface/Commands";
static const char CONFIGURATION_POP_ELEMENT_ACCESS[] = "/UserInterface/Popups";
static const char CONFIGURATION_PROPERTY_LABEL[] = "Label";
static const char CONFIGURATION_PROPERTY_CONTEXT_LABEL[] = "ContextLabel";
// Property names of the resulting Property Set
static const char PROPSET_LABEL[] = "Label";
static const char PROPSET_NAME[] = "Name";
static const char PROPSET_POPUP[] = "Popup";
static const char PROPSET_PROPERTIES[] = "Properties";
// Special resource URLs to retrieve additional information
static const char PRIVATE_RESOURCE_URL[] = "private:";
const sal_Int32 COMMAND_PROPERTY_IMAGE = 1;
const sal_Int32 COMMAND_PROPERTY_ROTATE = 2;
const sal_Int32 COMMAND_PROPERTY_MIRROR = 4;
namespace framework
{
//*****************************************************************************************************************
// Configuration access class for PopupMenuControllerFactory implementation
//*****************************************************************************************************************
class ConfigurationAccess_UICommand : // interfaces
public XTypeProvider ,
public XNameAccess ,
public XContainerListener ,
// baseclasses
// Order is neccessary for right initialization!
private ThreadHelpBase ,
public ::cppu::OWeakObject
{
public:
ConfigurationAccess_UICommand( const ::rtl::OUString& aModuleName, const Reference< XNameAccess >& xGenericUICommands, const Reference< XMultiServiceFactory >& rServiceManager );
virtual ~ConfigurationAccess_UICommand();
// XInterface, XTypeProvider
DECLARE_XINTERFACE
DECLARE_XTYPEPROVIDER
// XNameAccess
virtual ::com::sun::star::uno::Any SAL_CALL getByName( const ::rtl::OUString& aName )
throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getElementNames()
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName )
throw (::com::sun::star::uno::RuntimeException);
// XElementAccess
virtual ::com::sun::star::uno::Type SAL_CALL getElementType()
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL hasElements()
throw (::com::sun::star::uno::RuntimeException);
// container.XContainerListener
virtual void SAL_CALL elementInserted( const ContainerEvent& aEvent ) throw(RuntimeException);
virtual void SAL_CALL elementRemoved ( const ContainerEvent& aEvent ) throw(RuntimeException);
virtual void SAL_CALL elementReplaced( const ContainerEvent& aEvent ) throw(RuntimeException);
// lang.XEventListener
virtual void SAL_CALL disposing( const EventObject& aEvent ) throw(RuntimeException);
protected:
struct CmdToInfoMap
{
CmdToInfoMap() : bPopup( sal_False ),
bCommandNameCreated( sal_False ),
nProperties( 0 ) {}
rtl::OUString aLabel;
rtl::OUString aContextLabel;
rtl::OUString aCommandName;
sal_Bool bPopup : 1,
bCommandNameCreated : 1;
sal_Int32 nProperties;
};
Any getSequenceFromCache( const rtl::OUString& aCommandURL );
Any getInfoFromCommand( const rtl::OUString& rCommandURL );
void fillInfoFromResult( CmdToInfoMap& rCmdInfo, const rtl::OUString& aLabel );
Any getUILabelFromCommand( const rtl::OUString& rCommandURL );
Sequence< rtl::OUString > getAllCommands();
void resetCache();
sal_Bool fillCache();
sal_Bool addGenericInfoToCache();
private:
typedef ::std::hash_map< ::rtl::OUString,
CmdToInfoMap,
OUStringHashCode,
::std::equal_to< ::rtl::OUString > > CommandToInfoCache;
sal_Bool initializeConfigAccess();
rtl::OUString m_aConfigCmdAccess;
rtl::OUString m_aConfigPopupAccess;
rtl::OUString m_aPropUILabel;
rtl::OUString m_aPropUIContextLabel;
rtl::OUString m_aPropLabel;
rtl::OUString m_aPropName;
rtl::OUString m_aPropPopup;
rtl::OUString m_aPropProperties;
rtl::OUString m_aBrandName;
rtl::OUString m_aXMLFileFormatVersion;
rtl::OUString m_aVersion;
rtl::OUString m_aExtension;
rtl::OUString m_aPrivateResourceURL;
Reference< XNameAccess > m_xGenericUICommands;
Reference< XMultiServiceFactory > m_xServiceManager;
Reference< XMultiServiceFactory > m_xConfigProvider;
Reference< XMultiServiceFactory > m_xConfigProviderPopups;
Reference< XNameAccess > m_xConfigAccess;
Reference< XNameAccess > m_xConfigAccessPopups;
Sequence< rtl::OUString > m_aCommandImageList;
Sequence< rtl::OUString > m_aCommandRotateImageList;
Sequence< rtl::OUString > m_aCommandMirrorImageList;
CommandToInfoCache m_aCmdInfoCache;
sal_Bool m_bConfigAccessInitialized;
sal_Bool m_bCacheFilled;
sal_Bool m_bGenericDataRetrieved;
};
//*****************************************************************************************************************
// XInterface, XTypeProvider
//*****************************************************************************************************************
DEFINE_XINTERFACE_5 ( ConfigurationAccess_UICommand ,
OWeakObject ,
DIRECT_INTERFACE ( css::container::XNameAccess ),
DIRECT_INTERFACE ( css::container::XContainerListener ),
DIRECT_INTERFACE ( css::lang::XTypeProvider ),
DERIVED_INTERFACE( css::container::XElementAccess, css::container::XNameAccess ),
DERIVED_INTERFACE( css::lang::XEventListener, XContainerListener )
)
DEFINE_XTYPEPROVIDER_5 ( ConfigurationAccess_UICommand ,
css::container::XNameAccess ,
css::container::XElementAccess ,
css::container::XContainerListener ,
css::lang::XTypeProvider ,
css::lang::XEventListener
)
ConfigurationAccess_UICommand::ConfigurationAccess_UICommand( const rtl::OUString& aModuleName, const Reference< XNameAccess >& rGenericUICommands, const Reference< XMultiServiceFactory >& rServiceManager ) :
ThreadHelpBase(),
m_xServiceManager( rServiceManager ),
m_aPropUILabel( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_PROPERTY_LABEL )),
m_aPropUIContextLabel( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_PROPERTY_CONTEXT_LABEL )),
m_bConfigAccessInitialized( sal_False ),
m_bCacheFilled( sal_False ),
m_bGenericDataRetrieved( sal_False ),
m_aConfigCmdAccess( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_ROOT_ACCESS )),
m_aConfigPopupAccess( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_ROOT_ACCESS )),
m_aPropLabel( RTL_CONSTASCII_USTRINGPARAM( PROPSET_LABEL )),
m_aPropName( RTL_CONSTASCII_USTRINGPARAM( PROPSET_NAME )),
m_aPropPopup( RTL_CONSTASCII_USTRINGPARAM( PROPSET_POPUP )),
m_aPropProperties( RTL_CONSTASCII_USTRINGPARAM( PROPSET_PROPERTIES )),
m_aPrivateResourceURL( RTL_CONSTASCII_USTRINGPARAM( PRIVATE_RESOURCE_URL )),
m_xGenericUICommands( rGenericUICommands )
{
// Create configuration hierachical access name
m_aConfigCmdAccess += aModuleName;
m_aConfigCmdAccess += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_CMD_ELEMENT_ACCESS ));
m_xConfigProvider = Reference< XMultiServiceFactory >( rServiceManager->createInstance(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationProvider" ))),
UNO_QUERY );
m_aConfigPopupAccess += aModuleName;
m_aConfigPopupAccess += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_POP_ELEMENT_ACCESS ));
m_xConfigProviderPopups = Reference< XMultiServiceFactory >( rServiceManager->createInstance(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationProvider" ))),
UNO_QUERY );
Any aRet = ::utl::ConfigManager::GetDirectConfigProperty( ::utl::ConfigManager::PRODUCTNAME );
rtl::OUString aTmp;
aRet >>= aTmp;
m_aBrandName = aTmp;
}
ConfigurationAccess_UICommand::~ConfigurationAccess_UICommand()
{
// SAFE
ResetableGuard aLock( m_aLock );
Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );
if ( xContainer.is() )
xContainer->removeContainerListener( this );
xContainer = Reference< XContainer >( m_xConfigAccessPopups, UNO_QUERY );
if ( xContainer.is() )
xContainer->removeContainerListener( this );
}
// XNameAccess
Any SAL_CALL ConfigurationAccess_UICommand::getByName( const ::rtl::OUString& rCommandURL )
throw ( NoSuchElementException, WrappedTargetException, RuntimeException)
{
static sal_Int32 nRequests = 0;
ResetableGuard aLock( m_aLock );
if ( !m_bConfigAccessInitialized )
{
initializeConfigAccess();
m_bConfigAccessInitialized = sal_True;
fillCache();
}
if ( rCommandURL.indexOf( m_aPrivateResourceURL ) == 0 )
{
// special keys to retrieve information about a set of commands
// SAFE
addGenericInfoToCache();
if ( rCommandURL.equalsIgnoreAsciiCaseAscii( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDIMAGELIST ))
return makeAny( m_aCommandImageList );
else if ( rCommandURL.equalsIgnoreAsciiCaseAscii( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDROTATEIMAGELIST ))
return makeAny( m_aCommandRotateImageList );
else if ( rCommandURL.equalsIgnoreAsciiCaseAscii( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDMIRRORIMAGELIST ))
return makeAny( m_aCommandMirrorImageList );
else
throw NoSuchElementException();
}
else
{
// SAFE
++nRequests;
Any a = getInfoFromCommand( rCommandURL );
if ( !a.hasValue() )
throw NoSuchElementException();
return a;
}
}
Sequence< ::rtl::OUString > SAL_CALL ConfigurationAccess_UICommand::getElementNames()
throw ( RuntimeException )
{
return getAllCommands();
}
sal_Bool SAL_CALL ConfigurationAccess_UICommand::hasByName( const ::rtl::OUString& rCommandURL )
throw (::com::sun::star::uno::RuntimeException)
{
Any a = getByName( rCommandURL );
if ( a != Any() )
return sal_True;
else
return sal_False;
}
// XElementAccess
Type SAL_CALL ConfigurationAccess_UICommand::getElementType()
throw ( RuntimeException )
{
return( ::getCppuType( (const Sequence< PropertyValue >*)NULL ) );
}
sal_Bool SAL_CALL ConfigurationAccess_UICommand::hasElements()
throw ( RuntimeException )
{
// There must are global commands!
return sal_True;
}
void ConfigurationAccess_UICommand::fillInfoFromResult( CmdToInfoMap& rCmdInfo, const rtl::OUString& aLabel )
{
String rStr( aLabel );
if ( rStr.SearchAscii( "%PRODUCT" ) != STRING_NOTFOUND )
rStr.SearchAndReplaceAllAscii( "%PRODUCTNAME", m_aBrandName );
rCmdInfo.aLabel = OUString( rStr );
rStr.EraseTrailingChars( '.' ); // Remove "..." from string
rCmdInfo.aCommandName = OUString( MnemonicGenerator::EraseAllMnemonicChars( rStr ));
rCmdInfo.bCommandNameCreated = sal_True;
}
Any ConfigurationAccess_UICommand::getSequenceFromCache( const OUString& aCommandURL )
{
CommandToInfoCache::iterator pIter = m_aCmdInfoCache.find( aCommandURL );
if ( pIter != m_aCmdInfoCache.end() )
{
if ( !pIter->second.bCommandNameCreated )
fillInfoFromResult( pIter->second, pIter->second.aLabel );
Sequence< PropertyValue > aPropSeq( 3 );
aPropSeq[0].Name = m_aPropLabel;
aPropSeq[0].Value = pIter->second.aContextLabel.getLength() ?
makeAny( pIter->second.aContextLabel ): makeAny( pIter->second.aLabel );
aPropSeq[1].Name = m_aPropName;
aPropSeq[1].Value = makeAny( pIter->second.aCommandName );
aPropSeq[2].Name = m_aPropPopup;
aPropSeq[2].Value = makeAny( pIter->second.bPopup );
return makeAny( aPropSeq );
}
return Any();
}
void ConfigurationAccess_UICommand::resetCache()
{
m_aCmdInfoCache.clear();
m_bCacheFilled = sal_False;
m_bGenericDataRetrieved = sal_False;
}
sal_Bool ConfigurationAccess_UICommand::fillCache()
{
RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ConfigurationAccess_UICommand::fillCache" );
if ( m_bCacheFilled )
return sal_True;
sal_Int32 i( 0 );
Any a;
std::vector< OUString > aImageCommandVector;
std::vector< OUString > aImageRotateVector;
std::vector< OUString > aImageMirrorVector;
Sequence< OUString > aNameSeq;
if ( m_xConfigAccess.is() )
{
aNameSeq = m_xConfigAccess->getElementNames();
for ( i = 0; i < aNameSeq.getLength(); i++ )
{
try
{
Reference< XNameAccess > xNameAccess;
a = m_xConfigAccess->getByName( aNameSeq[i] );
if ( a >>= xNameAccess )
{
CmdToInfoMap aCmdToInfo;
a = xNameAccess->getByName( m_aPropUILabel );
a >>= aCmdToInfo.aLabel;
a = xNameAccess->getByName( m_aPropUIContextLabel );
a >>= aCmdToInfo.aContextLabel;
a = xNameAccess->getByName( m_aPropProperties );
a >>= aCmdToInfo.nProperties;
m_aCmdInfoCache.insert( CommandToInfoCache::value_type( aNameSeq[i], aCmdToInfo ));
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_IMAGE )
aImageCommandVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_ROTATE )
aImageRotateVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_MIRROR )
aImageMirrorVector.push_back( aNameSeq[i] );
}
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
catch ( com::sun::star::container::NoSuchElementException& )
{
}
}
}
if ( m_xConfigAccessPopups.is() )
{
aNameSeq = m_xConfigAccessPopups->getElementNames();
for ( i = 0; i < aNameSeq.getLength(); i++ )
{
try
{
Reference< XNameAccess > xNameAccess;
a = m_xConfigAccessPopups->getByName( aNameSeq[i] );
if ( a >>= xNameAccess )
{
CmdToInfoMap aCmdToInfo;
aCmdToInfo.bPopup = sal_True;
a = xNameAccess->getByName( m_aPropUILabel );
a >>= aCmdToInfo.aLabel;
a = xNameAccess->getByName( m_aPropUIContextLabel );
a >>= aCmdToInfo.aContextLabel;
a = xNameAccess->getByName( m_aPropProperties );
a >>= aCmdToInfo.nProperties;
m_aCmdInfoCache.insert( CommandToInfoCache::value_type( aNameSeq[i], aCmdToInfo ));
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_IMAGE )
aImageCommandVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_ROTATE )
aImageRotateVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_MIRROR )
aImageMirrorVector.push_back( aNameSeq[i] );
}
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
catch ( com::sun::star::container::NoSuchElementException& )
{
}
}
}
// Create cached sequences for fast retrieving
m_aCommandImageList = comphelper::containerToSequence( aImageCommandVector );
m_aCommandRotateImageList = comphelper::containerToSequence( aImageRotateVector );
m_aCommandMirrorImageList = comphelper::containerToSequence( aImageMirrorVector );
m_bCacheFilled = sal_True;
return sal_True;
}
sal_Bool ConfigurationAccess_UICommand::addGenericInfoToCache()
{
if ( m_xGenericUICommands.is() && !m_bGenericDataRetrieved )
{
Sequence< rtl::OUString > aCommandNameSeq;
try
{
if ( m_xGenericUICommands->getByName(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDROTATEIMAGELIST ))) >>= aCommandNameSeq )
m_aCommandRotateImageList = comphelper::concatSequences< rtl::OUString >( m_aCommandRotateImageList, aCommandNameSeq );
}
catch ( RuntimeException& e )
{
throw e;
}
catch ( Exception& )
{
}
try
{
if ( m_xGenericUICommands->getByName(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDMIRRORIMAGELIST ))) >>= aCommandNameSeq )
m_aCommandMirrorImageList = comphelper::concatSequences< rtl::OUString >( m_aCommandMirrorImageList, aCommandNameSeq );
}
catch ( RuntimeException& e )
{
throw e;
}
catch ( Exception& )
{
}
m_bGenericDataRetrieved = sal_True;
}
return sal_True;
}
Any ConfigurationAccess_UICommand::getInfoFromCommand( const rtl::OUString& rCommandURL )
{
Any a;
try
{
a = getSequenceFromCache( rCommandURL );
if ( !a.hasValue() )
{
// First try to ask our global commands configuration access. It also caches maybe
// we find the entry in its cache first.
if ( m_xGenericUICommands.is() )
{
try
{
return m_xGenericUICommands->getByName( rCommandURL );
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
catch ( com::sun::star::container::NoSuchElementException& )
{
}
}
}
}
catch( com::sun::star::container::NoSuchElementException& )
{
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
return a;
}
Sequence< rtl::OUString > ConfigurationAccess_UICommand::getAllCommands()
{
// SAFE
ResetableGuard aLock( m_aLock );
if ( !m_bConfigAccessInitialized )
{
initializeConfigAccess();
m_bConfigAccessInitialized = sal_True;
fillCache();
}
if ( m_xConfigAccess.is() )
{
Any a;
Reference< XNameAccess > xNameAccess;
try
{
Sequence< OUString > aNameSeq = m_xConfigAccess->getElementNames();
if ( m_xGenericUICommands.is() )
{
// Create concat list of supported user interface commands of the module
Sequence< OUString > aGenericNameSeq = m_xGenericUICommands->getElementNames();
sal_uInt32 nCount1 = aNameSeq.getLength();
sal_uInt32 nCount2 = aGenericNameSeq.getLength();
aNameSeq.realloc( nCount1 + nCount2 );
OUString* pNameSeq = aNameSeq.getArray();
const OUString* pGenericSeq = aGenericNameSeq.getConstArray();
for ( sal_uInt32 i = 0; i < nCount2; i++ )
pNameSeq[nCount1+i] = pGenericSeq[i];
}
return aNameSeq;
}
catch( com::sun::star::container::NoSuchElementException& )
{
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
}
return Sequence< rtl::OUString >();
}
sal_Bool ConfigurationAccess_UICommand::initializeConfigAccess()
{
Sequence< Any > aArgs( 1 );
PropertyValue aPropValue;
try
{
aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "nodepath" ));
aPropValue.Value = makeAny( m_aConfigCmdAccess );
aArgs[0] <<= aPropValue;
m_xConfigAccess = Reference< XNameAccess >( m_xConfigProvider->createInstanceWithArguments(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationAccess" )),
aArgs ),
UNO_QUERY );
if ( m_xConfigAccess.is() )
{
// Add as container listener
Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );
if ( xContainer.is() )
xContainer->addContainerListener( this );
}
aPropValue.Value = makeAny( m_aConfigPopupAccess );
aArgs[0] <<= aPropValue;
m_xConfigAccessPopups = Reference< XNameAccess >( m_xConfigProvider->createInstanceWithArguments(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationAccess" )),
aArgs ),
UNO_QUERY );
if ( m_xConfigAccessPopups.is() )
{
// Add as container listener
Reference< XContainer > xContainer( m_xConfigAccessPopups, UNO_QUERY );
if ( xContainer.is() )
xContainer->addContainerListener( this );
}
return sal_True;
}
catch ( WrappedTargetException& )
{
}
catch ( Exception& )
{
}
return sal_False;
}
// container.XContainerListener
void SAL_CALL ConfigurationAccess_UICommand::elementInserted( const ContainerEvent& aEvent ) throw(RuntimeException)
{
}
void SAL_CALL ConfigurationAccess_UICommand::elementRemoved ( const ContainerEvent& aEvent ) throw(RuntimeException)
{
}
void SAL_CALL ConfigurationAccess_UICommand::elementReplaced( const ContainerEvent& aEvent ) throw(RuntimeException)
{
}
// lang.XEventListener
void SAL_CALL ConfigurationAccess_UICommand::disposing( const EventObject& aEvent ) throw(RuntimeException)
{
// SAFE
// remove our reference to the config access
ResetableGuard aLock( m_aLock );
Reference< XInterface > xIfac1( aEvent.Source, UNO_QUERY );
Reference< XInterface > xIfac2( m_xConfigAccess, UNO_QUERY );
if ( xIfac1 == xIfac2 )
m_xConfigAccess.clear();
else
{
xIfac2 = Reference< XInterface >( m_xConfigAccessPopups, UNO_QUERY );
if ( xIfac1 == xIfac2 )
m_xConfigAccessPopups.clear();
}
}
//*****************************************************************************************************************
// XInterface, XTypeProvider, XServiceInfo
//*****************************************************************************************************************
DEFINE_XINTERFACE_4 ( UICommandDescription ,
OWeakObject ,
DIRECT_INTERFACE( css::lang::XTypeProvider ),
DIRECT_INTERFACE( css::lang::XServiceInfo ),
DIRECT_INTERFACE( css::container::XNameAccess ),
DERIVED_INTERFACE( css::container::XElementAccess, css::container::XNameAccess )
)
DEFINE_XTYPEPROVIDER_4 ( UICommandDescription ,
css::lang::XTypeProvider ,
css::lang::XServiceInfo ,
css::container::XNameAccess ,
css::container::XElementAccess
)
DEFINE_XSERVICEINFO_ONEINSTANCESERVICE ( UICommandDescription ,
::cppu::OWeakObject ,
SERVICENAME_UICOMMANDDESCRIPTION ,
IMPLEMENTATIONNAME_UICOMMANDDESCRIPTION
)
DEFINE_INIT_SERVICE ( UICommandDescription, {} )
UICommandDescription::UICommandDescription( const Reference< XMultiServiceFactory >& xServiceManager ) :
ThreadHelpBase(),
m_aPrivateResourceURL( RTL_CONSTASCII_USTRINGPARAM( PRIVATE_RESOURCE_URL )),
m_xServiceManager( xServiceManager )
{
Reference< XNameAccess > xEmpty;
rtl::OUString aGenericUICommand( OUString::createFromAscii( "GenericCommands" ));
m_xGenericUICommands = new ConfigurationAccess_UICommand( aGenericUICommand, xEmpty, xServiceManager );
m_xModuleManager = Reference< XModuleManager >( m_xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ),
UNO_QUERY );
Reference< XNameAccess > xNameAccess( m_xModuleManager, UNO_QUERY_THROW );
Sequence< rtl::OUString > aElementNames = xNameAccess->getElementNames();
Sequence< PropertyValue > aSeq;
OUString aModuleIdentifier;
for ( sal_Int32 i = 0; i < aElementNames.getLength(); i++ )
{
aModuleIdentifier = aElementNames[i];
Any a = xNameAccess->getByName( aModuleIdentifier );
if ( a >>= aSeq )
{
OUString aCommandStr;
for ( sal_Int32 y = 0; y < aSeq.getLength(); y++ )
{
if ( aSeq[y].Name.equalsAscii("ooSetupFactoryCommandConfigRef") )
{
aSeq[y].Value >>= aCommandStr;
break;
}
}
// Create first mapping ModuleIdentifier ==> Command File
m_aModuleToCommandFileMap.insert( ModuleToCommandFileMap::value_type( aModuleIdentifier, aCommandStr ));
// Create second mapping Command File ==> commands instance
UICommandsHashMap::iterator pIter = m_aUICommandsHashMap.find( aCommandStr );
if ( pIter == m_aUICommandsHashMap.end() )
m_aUICommandsHashMap.insert( UICommandsHashMap::value_type( aCommandStr, Reference< XNameAccess >() ));
}
}
// insert generic commands
UICommandsHashMap::iterator pIter = m_aUICommandsHashMap.find( aGenericUICommand );
if ( pIter != m_aUICommandsHashMap.end() )
pIter->second = m_xGenericUICommands;
}
UICommandDescription::~UICommandDescription()
{
ResetableGuard aLock( m_aLock );
m_aModuleToCommandFileMap.clear();
m_aUICommandsHashMap.clear();
m_xGenericUICommands.clear();
}
Any SAL_CALL UICommandDescription::getByName( const ::rtl::OUString& aName )
throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
{
Any a;
ResetableGuard aLock( m_aLock );
ModuleToCommandFileMap::const_iterator pIter = m_aModuleToCommandFileMap.find( aName );
if ( pIter != m_aModuleToCommandFileMap.end() )
{
OUString aCommandFile( pIter->second );
UICommandsHashMap::iterator pIter = m_aUICommandsHashMap.find( aCommandFile );
if ( pIter != m_aUICommandsHashMap.end() )
{
if ( pIter->second.is() )
a <<= pIter->second;
else
{
Reference< XNameAccess > xUICommands;
ConfigurationAccess_UICommand* pUICommands = new ConfigurationAccess_UICommand( aCommandFile,
m_xGenericUICommands,
m_xServiceManager );
xUICommands = Reference< XNameAccess >( static_cast< cppu::OWeakObject* >( pUICommands ),UNO_QUERY );
pIter->second = xUICommands;
a <<= xUICommands;
}
}
}
else if ( aName.indexOf( m_aPrivateResourceURL ) == 0 )
{
// special keys to retrieve information about a set of commands
return m_xGenericUICommands->getByName( aName );
}
else
{
throw NoSuchElementException();
}
return a;
}
Sequence< ::rtl::OUString > SAL_CALL UICommandDescription::getElementNames()
throw (::com::sun::star::uno::RuntimeException)
{
ResetableGuard aLock( m_aLock );
Sequence< rtl::OUString > aSeq( m_aModuleToCommandFileMap.size() );
sal_Int32 n = 0;
ModuleToCommandFileMap::const_iterator pIter = m_aModuleToCommandFileMap.begin();
while ( pIter != m_aModuleToCommandFileMap.end() )
{
aSeq[n] = pIter->first;
++pIter;
}
return aSeq;
}
sal_Bool SAL_CALL UICommandDescription::hasByName( const ::rtl::OUString& aName )
throw (::com::sun::star::uno::RuntimeException)
{
ResetableGuard aLock( m_aLock );
ModuleToCommandFileMap::const_iterator pIter = m_aModuleToCommandFileMap.find( aName );
return ( pIter != m_aModuleToCommandFileMap.end() );
}
// XElementAccess
Type SAL_CALL UICommandDescription::getElementType()
throw (::com::sun::star::uno::RuntimeException)
{
return( ::getCppuType( (const Reference< XNameAccess >*)NULL ) );
}
sal_Bool SAL_CALL UICommandDescription::hasElements()
throw (::com::sun::star::uno::RuntimeException)
{
// generic UI commands are always available!
return sal_True;
}
} // namespace framework
INTEGRATION: CWS warnings01 (1.9.4); FILE MERGED
2006/04/07 16:09:03 sb 1.9.4.4: RESYNC: (1.10-1.11); FILE MERGED
2005/11/16 15:20:47 pl 1.9.4.3: #i55991# removed warnings
2005/11/07 16:55:14 pl 1.9.4.2: RESYNC: (1.9-1.10); FILE MERGED
2005/10/28 14:48:46 cd 1.9.4.1: #i55991# Warning free code changes for gcc
/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: uicommanddescription.cxx,v $
*
* $Revision: 1.12 $
*
* last change: $Author: hr $ $Date: 2006-06-19 11:42:47 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
//_________________________________________________________________________________________________________________
// my own includes
//_________________________________________________________________________________________________________________
#ifndef __FRAMEWORK_UIELEMENT_UICOMMANDDESCRPTION_HXX_
#include "uielement/uicommanddescription.hxx"
#endif
#ifndef __FRAMEWORK_THREADHELP_RESETABLEGUARD_HXX_
#include <threadhelp/resetableguard.hxx>
#endif
#ifndef __FRAMEWORK_SERVICES_H_
#include "services.h"
#endif
#include "properties.h"
//_________________________________________________________________________________________________________________
// interface includes
//_________________________________________________________________________________________________________________
#ifndef _COM_SUN_STAR_BEANS_PROPERTYVALUE_HPP_
#include <com/sun/star/beans/PropertyValue.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_XPROPERTYSET_HPP_
#include <com/sun/star/beans/XPropertySet.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_
#include <com/sun/star/container/XNameAccess.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_
#include <com/sun/star/container/XNameContainer.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XCONTAINER_HPP_
#include <com/sun/star/container/XContainer.hpp>
#endif
//_________________________________________________________________________________________________________________
// includes of other projects
//_________________________________________________________________________________________________________________
#ifndef _RTL_USTRBUF_HXX_
#include <rtl/ustrbuf.hxx>
#endif
#ifndef _CPPUHELPER_WEAK_HXX_
#include <cppuhelper/weak.hxx>
#endif
#ifndef _UTL_CONFIGMGR_HXX_
#include <unotools/configmgr.hxx>
#endif
#ifndef _STRING_HXX
#include <tools/string.hxx>
#endif
#ifndef _VCL_MNEMONIC_HXX_
#include <vcl/mnemonic.hxx>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _RTL_LOGFILE_HXX_
#include <rtl/logfile.hxx>
#endif
//_________________________________________________________________________________________________________________
// Defines
//_________________________________________________________________________________________________________________
//
using namespace rtl;
using namespace com::sun::star::uno;
using namespace com::sun::star::lang;
using namespace com::sun::star::beans;
using namespace com::sun::star::container;
using namespace ::com::sun::star::frame;
//_________________________________________________________________________________________________________________
// Namespace
//_________________________________________________________________________________________________________________
//
struct ModuleToCommands
{
const char* pModuleId;
const char* pCommands;
};
static const char GENERIC_UICOMMANDS[] = "generic";
static const char COMMANDS[] = "Commands";
static const char CONFIGURATION_ROOT_ACCESS[] = "/org.openoffice.Office.UI.";
static const char CONFIGURATION_CMD_ELEMENT_ACCESS[] = "/UserInterface/Commands";
static const char CONFIGURATION_POP_ELEMENT_ACCESS[] = "/UserInterface/Popups";
static const char CONFIGURATION_PROPERTY_LABEL[] = "Label";
static const char CONFIGURATION_PROPERTY_CONTEXT_LABEL[] = "ContextLabel";
// Property names of the resulting Property Set
static const char PROPSET_LABEL[] = "Label";
static const char PROPSET_NAME[] = "Name";
static const char PROPSET_POPUP[] = "Popup";
static const char PROPSET_PROPERTIES[] = "Properties";
// Special resource URLs to retrieve additional information
static const char PRIVATE_RESOURCE_URL[] = "private:";
const sal_Int32 COMMAND_PROPERTY_IMAGE = 1;
const sal_Int32 COMMAND_PROPERTY_ROTATE = 2;
const sal_Int32 COMMAND_PROPERTY_MIRROR = 4;
namespace framework
{
//*****************************************************************************************************************
// Configuration access class for PopupMenuControllerFactory implementation
//*****************************************************************************************************************
class ConfigurationAccess_UICommand : // interfaces
public XTypeProvider ,
public XNameAccess ,
public XContainerListener ,
// baseclasses
// Order is neccessary for right initialization!
private ThreadHelpBase ,
public ::cppu::OWeakObject
{
public:
ConfigurationAccess_UICommand( const ::rtl::OUString& aModuleName, const Reference< XNameAccess >& xGenericUICommands, const Reference< XMultiServiceFactory >& rServiceManager );
virtual ~ConfigurationAccess_UICommand();
// XInterface, XTypeProvider
FWK_DECLARE_XINTERFACE
FWK_DECLARE_XTYPEPROVIDER
// XNameAccess
virtual ::com::sun::star::uno::Any SAL_CALL getByName( const ::rtl::OUString& aName )
throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getElementNames()
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName )
throw (::com::sun::star::uno::RuntimeException);
// XElementAccess
virtual ::com::sun::star::uno::Type SAL_CALL getElementType()
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL hasElements()
throw (::com::sun::star::uno::RuntimeException);
// container.XContainerListener
virtual void SAL_CALL elementInserted( const ContainerEvent& aEvent ) throw(RuntimeException);
virtual void SAL_CALL elementRemoved ( const ContainerEvent& aEvent ) throw(RuntimeException);
virtual void SAL_CALL elementReplaced( const ContainerEvent& aEvent ) throw(RuntimeException);
// lang.XEventListener
virtual void SAL_CALL disposing( const EventObject& aEvent ) throw(RuntimeException);
protected:
struct CmdToInfoMap
{
CmdToInfoMap() : bPopup( sal_False ),
bCommandNameCreated( sal_False ),
nProperties( 0 ) {}
rtl::OUString aLabel;
rtl::OUString aContextLabel;
rtl::OUString aCommandName;
sal_Bool bPopup : 1,
bCommandNameCreated : 1;
sal_Int32 nProperties;
};
Any getSequenceFromCache( const rtl::OUString& aCommandURL );
Any getInfoFromCommand( const rtl::OUString& rCommandURL );
void fillInfoFromResult( CmdToInfoMap& rCmdInfo, const rtl::OUString& aLabel );
Any getUILabelFromCommand( const rtl::OUString& rCommandURL );
Sequence< rtl::OUString > getAllCommands();
void resetCache();
sal_Bool fillCache();
sal_Bool addGenericInfoToCache();
private:
typedef ::std::hash_map< ::rtl::OUString,
CmdToInfoMap,
OUStringHashCode,
::std::equal_to< ::rtl::OUString > > CommandToInfoCache;
sal_Bool initializeConfigAccess();
rtl::OUString m_aConfigCmdAccess;
rtl::OUString m_aConfigPopupAccess;
rtl::OUString m_aPropUILabel;
rtl::OUString m_aPropUIContextLabel;
rtl::OUString m_aPropLabel;
rtl::OUString m_aPropName;
rtl::OUString m_aPropPopup;
rtl::OUString m_aPropProperties;
rtl::OUString m_aBrandName;
rtl::OUString m_aXMLFileFormatVersion;
rtl::OUString m_aVersion;
rtl::OUString m_aExtension;
rtl::OUString m_aPrivateResourceURL;
Reference< XNameAccess > m_xGenericUICommands;
Reference< XMultiServiceFactory > m_xServiceManager;
Reference< XMultiServiceFactory > m_xConfigProvider;
Reference< XMultiServiceFactory > m_xConfigProviderPopups;
Reference< XNameAccess > m_xConfigAccess;
Reference< XNameAccess > m_xConfigAccessPopups;
Sequence< rtl::OUString > m_aCommandImageList;
Sequence< rtl::OUString > m_aCommandRotateImageList;
Sequence< rtl::OUString > m_aCommandMirrorImageList;
CommandToInfoCache m_aCmdInfoCache;
sal_Bool m_bConfigAccessInitialized;
sal_Bool m_bCacheFilled;
sal_Bool m_bGenericDataRetrieved;
};
//*****************************************************************************************************************
// XInterface, XTypeProvider
//*****************************************************************************************************************
DEFINE_XINTERFACE_5 ( ConfigurationAccess_UICommand ,
OWeakObject ,
DIRECT_INTERFACE ( css::container::XNameAccess ),
DIRECT_INTERFACE ( css::container::XContainerListener ),
DIRECT_INTERFACE ( css::lang::XTypeProvider ),
DERIVED_INTERFACE( css::container::XElementAccess, css::container::XNameAccess ),
DERIVED_INTERFACE( css::lang::XEventListener, XContainerListener )
)
DEFINE_XTYPEPROVIDER_5 ( ConfigurationAccess_UICommand ,
css::container::XNameAccess ,
css::container::XElementAccess ,
css::container::XContainerListener ,
css::lang::XTypeProvider ,
css::lang::XEventListener
)
ConfigurationAccess_UICommand::ConfigurationAccess_UICommand( const rtl::OUString& aModuleName, const Reference< XNameAccess >& rGenericUICommands, const Reference< XMultiServiceFactory >& rServiceManager ) :
ThreadHelpBase(),
m_aConfigCmdAccess( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_ROOT_ACCESS )),
m_aConfigPopupAccess( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_ROOT_ACCESS )),
m_aPropUILabel( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_PROPERTY_LABEL )),
m_aPropUIContextLabel( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_PROPERTY_CONTEXT_LABEL )),
m_aPropLabel( RTL_CONSTASCII_USTRINGPARAM( PROPSET_LABEL )),
m_aPropName( RTL_CONSTASCII_USTRINGPARAM( PROPSET_NAME )),
m_aPropPopup( RTL_CONSTASCII_USTRINGPARAM( PROPSET_POPUP )),
m_aPropProperties( RTL_CONSTASCII_USTRINGPARAM( PROPSET_PROPERTIES )),
m_aPrivateResourceURL( RTL_CONSTASCII_USTRINGPARAM( PRIVATE_RESOURCE_URL )),
m_xGenericUICommands( rGenericUICommands ),
m_xServiceManager( rServiceManager ),
m_bConfigAccessInitialized( sal_False ),
m_bCacheFilled( sal_False ),
m_bGenericDataRetrieved( sal_False )
{
// Create configuration hierachical access name
m_aConfigCmdAccess += aModuleName;
m_aConfigCmdAccess += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_CMD_ELEMENT_ACCESS ));
m_xConfigProvider = Reference< XMultiServiceFactory >( rServiceManager->createInstance(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationProvider" ))),
UNO_QUERY );
m_aConfigPopupAccess += aModuleName;
m_aConfigPopupAccess += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CONFIGURATION_POP_ELEMENT_ACCESS ));
m_xConfigProviderPopups = Reference< XMultiServiceFactory >( rServiceManager->createInstance(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationProvider" ))),
UNO_QUERY );
Any aRet = ::utl::ConfigManager::GetDirectConfigProperty( ::utl::ConfigManager::PRODUCTNAME );
rtl::OUString aTmp;
aRet >>= aTmp;
m_aBrandName = aTmp;
}
ConfigurationAccess_UICommand::~ConfigurationAccess_UICommand()
{
// SAFE
ResetableGuard aLock( m_aLock );
Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );
if ( xContainer.is() )
xContainer->removeContainerListener( this );
xContainer = Reference< XContainer >( m_xConfigAccessPopups, UNO_QUERY );
if ( xContainer.is() )
xContainer->removeContainerListener( this );
}
// XNameAccess
Any SAL_CALL ConfigurationAccess_UICommand::getByName( const ::rtl::OUString& rCommandURL )
throw ( NoSuchElementException, WrappedTargetException, RuntimeException)
{
static sal_Int32 nRequests = 0;
ResetableGuard aLock( m_aLock );
if ( !m_bConfigAccessInitialized )
{
initializeConfigAccess();
m_bConfigAccessInitialized = sal_True;
fillCache();
}
if ( rCommandURL.indexOf( m_aPrivateResourceURL ) == 0 )
{
// special keys to retrieve information about a set of commands
// SAFE
addGenericInfoToCache();
if ( rCommandURL.equalsIgnoreAsciiCaseAscii( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDIMAGELIST ))
return makeAny( m_aCommandImageList );
else if ( rCommandURL.equalsIgnoreAsciiCaseAscii( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDROTATEIMAGELIST ))
return makeAny( m_aCommandRotateImageList );
else if ( rCommandURL.equalsIgnoreAsciiCaseAscii( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDMIRRORIMAGELIST ))
return makeAny( m_aCommandMirrorImageList );
else
throw NoSuchElementException();
}
else
{
// SAFE
++nRequests;
Any a = getInfoFromCommand( rCommandURL );
if ( !a.hasValue() )
throw NoSuchElementException();
return a;
}
}
Sequence< ::rtl::OUString > SAL_CALL ConfigurationAccess_UICommand::getElementNames()
throw ( RuntimeException )
{
return getAllCommands();
}
sal_Bool SAL_CALL ConfigurationAccess_UICommand::hasByName( const ::rtl::OUString& rCommandURL )
throw (::com::sun::star::uno::RuntimeException)
{
Any a = getByName( rCommandURL );
if ( a != Any() )
return sal_True;
else
return sal_False;
}
// XElementAccess
Type SAL_CALL ConfigurationAccess_UICommand::getElementType()
throw ( RuntimeException )
{
return( ::getCppuType( (const Sequence< PropertyValue >*)NULL ) );
}
sal_Bool SAL_CALL ConfigurationAccess_UICommand::hasElements()
throw ( RuntimeException )
{
// There must are global commands!
return sal_True;
}
void ConfigurationAccess_UICommand::fillInfoFromResult( CmdToInfoMap& rCmdInfo, const rtl::OUString& aLabel )
{
String rStr( aLabel );
if ( rStr.SearchAscii( "%PRODUCT" ) != STRING_NOTFOUND )
rStr.SearchAndReplaceAllAscii( "%PRODUCTNAME", m_aBrandName );
rCmdInfo.aLabel = OUString( rStr );
rStr.EraseTrailingChars( '.' ); // Remove "..." from string
rCmdInfo.aCommandName = OUString( MnemonicGenerator::EraseAllMnemonicChars( rStr ));
rCmdInfo.bCommandNameCreated = sal_True;
}
Any ConfigurationAccess_UICommand::getSequenceFromCache( const OUString& aCommandURL )
{
CommandToInfoCache::iterator pIter = m_aCmdInfoCache.find( aCommandURL );
if ( pIter != m_aCmdInfoCache.end() )
{
if ( !pIter->second.bCommandNameCreated )
fillInfoFromResult( pIter->second, pIter->second.aLabel );
Sequence< PropertyValue > aPropSeq( 3 );
aPropSeq[0].Name = m_aPropLabel;
aPropSeq[0].Value = pIter->second.aContextLabel.getLength() ?
makeAny( pIter->second.aContextLabel ): makeAny( pIter->second.aLabel );
aPropSeq[1].Name = m_aPropName;
aPropSeq[1].Value = makeAny( pIter->second.aCommandName );
aPropSeq[2].Name = m_aPropPopup;
aPropSeq[2].Value = makeAny( pIter->second.bPopup );
return makeAny( aPropSeq );
}
return Any();
}
void ConfigurationAccess_UICommand::resetCache()
{
m_aCmdInfoCache.clear();
m_bCacheFilled = sal_False;
m_bGenericDataRetrieved = sal_False;
}
sal_Bool ConfigurationAccess_UICommand::fillCache()
{
RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::ConfigurationAccess_UICommand::fillCache" );
if ( m_bCacheFilled )
return sal_True;
sal_Int32 i( 0 );
Any a;
std::vector< OUString > aImageCommandVector;
std::vector< OUString > aImageRotateVector;
std::vector< OUString > aImageMirrorVector;
Sequence< OUString > aNameSeq;
if ( m_xConfigAccess.is() )
{
aNameSeq = m_xConfigAccess->getElementNames();
for ( i = 0; i < aNameSeq.getLength(); i++ )
{
try
{
Reference< XNameAccess > xNameAccess;
a = m_xConfigAccess->getByName( aNameSeq[i] );
if ( a >>= xNameAccess )
{
CmdToInfoMap aCmdToInfo;
a = xNameAccess->getByName( m_aPropUILabel );
a >>= aCmdToInfo.aLabel;
a = xNameAccess->getByName( m_aPropUIContextLabel );
a >>= aCmdToInfo.aContextLabel;
a = xNameAccess->getByName( m_aPropProperties );
a >>= aCmdToInfo.nProperties;
m_aCmdInfoCache.insert( CommandToInfoCache::value_type( aNameSeq[i], aCmdToInfo ));
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_IMAGE )
aImageCommandVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_ROTATE )
aImageRotateVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_MIRROR )
aImageMirrorVector.push_back( aNameSeq[i] );
}
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
catch ( com::sun::star::container::NoSuchElementException& )
{
}
}
}
if ( m_xConfigAccessPopups.is() )
{
aNameSeq = m_xConfigAccessPopups->getElementNames();
for ( i = 0; i < aNameSeq.getLength(); i++ )
{
try
{
Reference< XNameAccess > xNameAccess;
a = m_xConfigAccessPopups->getByName( aNameSeq[i] );
if ( a >>= xNameAccess )
{
CmdToInfoMap aCmdToInfo;
aCmdToInfo.bPopup = sal_True;
a = xNameAccess->getByName( m_aPropUILabel );
a >>= aCmdToInfo.aLabel;
a = xNameAccess->getByName( m_aPropUIContextLabel );
a >>= aCmdToInfo.aContextLabel;
a = xNameAccess->getByName( m_aPropProperties );
a >>= aCmdToInfo.nProperties;
m_aCmdInfoCache.insert( CommandToInfoCache::value_type( aNameSeq[i], aCmdToInfo ));
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_IMAGE )
aImageCommandVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_ROTATE )
aImageRotateVector.push_back( aNameSeq[i] );
if ( aCmdToInfo.nProperties & COMMAND_PROPERTY_MIRROR )
aImageMirrorVector.push_back( aNameSeq[i] );
}
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
catch ( com::sun::star::container::NoSuchElementException& )
{
}
}
}
// Create cached sequences for fast retrieving
m_aCommandImageList = comphelper::containerToSequence( aImageCommandVector );
m_aCommandRotateImageList = comphelper::containerToSequence( aImageRotateVector );
m_aCommandMirrorImageList = comphelper::containerToSequence( aImageMirrorVector );
m_bCacheFilled = sal_True;
return sal_True;
}
sal_Bool ConfigurationAccess_UICommand::addGenericInfoToCache()
{
if ( m_xGenericUICommands.is() && !m_bGenericDataRetrieved )
{
Sequence< rtl::OUString > aCommandNameSeq;
try
{
if ( m_xGenericUICommands->getByName(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDROTATEIMAGELIST ))) >>= aCommandNameSeq )
m_aCommandRotateImageList = comphelper::concatSequences< rtl::OUString >( m_aCommandRotateImageList, aCommandNameSeq );
}
catch ( RuntimeException& e )
{
throw e;
}
catch ( Exception& )
{
}
try
{
if ( m_xGenericUICommands->getByName(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UICOMMANDDESCRIPTION_NAMEACCESS_COMMANDMIRRORIMAGELIST ))) >>= aCommandNameSeq )
m_aCommandMirrorImageList = comphelper::concatSequences< rtl::OUString >( m_aCommandMirrorImageList, aCommandNameSeq );
}
catch ( RuntimeException& e )
{
throw e;
}
catch ( Exception& )
{
}
m_bGenericDataRetrieved = sal_True;
}
return sal_True;
}
Any ConfigurationAccess_UICommand::getInfoFromCommand( const rtl::OUString& rCommandURL )
{
Any a;
try
{
a = getSequenceFromCache( rCommandURL );
if ( !a.hasValue() )
{
// First try to ask our global commands configuration access. It also caches maybe
// we find the entry in its cache first.
if ( m_xGenericUICommands.is() )
{
try
{
return m_xGenericUICommands->getByName( rCommandURL );
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
catch ( com::sun::star::container::NoSuchElementException& )
{
}
}
}
}
catch( com::sun::star::container::NoSuchElementException& )
{
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
return a;
}
Sequence< rtl::OUString > ConfigurationAccess_UICommand::getAllCommands()
{
// SAFE
ResetableGuard aLock( m_aLock );
if ( !m_bConfigAccessInitialized )
{
initializeConfigAccess();
m_bConfigAccessInitialized = sal_True;
fillCache();
}
if ( m_xConfigAccess.is() )
{
Any a;
Reference< XNameAccess > xNameAccess;
try
{
Sequence< OUString > aNameSeq = m_xConfigAccess->getElementNames();
if ( m_xGenericUICommands.is() )
{
// Create concat list of supported user interface commands of the module
Sequence< OUString > aGenericNameSeq = m_xGenericUICommands->getElementNames();
sal_uInt32 nCount1 = aNameSeq.getLength();
sal_uInt32 nCount2 = aGenericNameSeq.getLength();
aNameSeq.realloc( nCount1 + nCount2 );
OUString* pNameSeq = aNameSeq.getArray();
const OUString* pGenericSeq = aGenericNameSeq.getConstArray();
for ( sal_uInt32 i = 0; i < nCount2; i++ )
pNameSeq[nCount1+i] = pGenericSeq[i];
}
return aNameSeq;
}
catch( com::sun::star::container::NoSuchElementException& )
{
}
catch ( com::sun::star::lang::WrappedTargetException& )
{
}
}
return Sequence< rtl::OUString >();
}
sal_Bool ConfigurationAccess_UICommand::initializeConfigAccess()
{
Sequence< Any > aArgs( 1 );
PropertyValue aPropValue;
try
{
aPropValue.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "nodepath" ));
aPropValue.Value = makeAny( m_aConfigCmdAccess );
aArgs[0] <<= aPropValue;
m_xConfigAccess = Reference< XNameAccess >( m_xConfigProvider->createInstanceWithArguments(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationAccess" )),
aArgs ),
UNO_QUERY );
if ( m_xConfigAccess.is() )
{
// Add as container listener
Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );
if ( xContainer.is() )
xContainer->addContainerListener( this );
}
aPropValue.Value = makeAny( m_aConfigPopupAccess );
aArgs[0] <<= aPropValue;
m_xConfigAccessPopups = Reference< XNameAccess >( m_xConfigProvider->createInstanceWithArguments(
rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
"com.sun.star.configuration.ConfigurationAccess" )),
aArgs ),
UNO_QUERY );
if ( m_xConfigAccessPopups.is() )
{
// Add as container listener
Reference< XContainer > xContainer( m_xConfigAccessPopups, UNO_QUERY );
if ( xContainer.is() )
xContainer->addContainerListener( this );
}
return sal_True;
}
catch ( WrappedTargetException& )
{
}
catch ( Exception& )
{
}
return sal_False;
}
// container.XContainerListener
void SAL_CALL ConfigurationAccess_UICommand::elementInserted( const ContainerEvent& ) throw(RuntimeException)
{
}
void SAL_CALL ConfigurationAccess_UICommand::elementRemoved( const ContainerEvent& ) throw(RuntimeException)
{
}
void SAL_CALL ConfigurationAccess_UICommand::elementReplaced( const ContainerEvent& ) throw(RuntimeException)
{
}
// lang.XEventListener
void SAL_CALL ConfigurationAccess_UICommand::disposing( const EventObject& aEvent ) throw(RuntimeException)
{
// SAFE
// remove our reference to the config access
ResetableGuard aLock( m_aLock );
Reference< XInterface > xIfac1( aEvent.Source, UNO_QUERY );
Reference< XInterface > xIfac2( m_xConfigAccess, UNO_QUERY );
if ( xIfac1 == xIfac2 )
m_xConfigAccess.clear();
else
{
xIfac2 = Reference< XInterface >( m_xConfigAccessPopups, UNO_QUERY );
if ( xIfac1 == xIfac2 )
m_xConfigAccessPopups.clear();
}
}
//*****************************************************************************************************************
// XInterface, XTypeProvider, XServiceInfo
//*****************************************************************************************************************
DEFINE_XINTERFACE_4 ( UICommandDescription ,
OWeakObject ,
DIRECT_INTERFACE( css::lang::XTypeProvider ),
DIRECT_INTERFACE( css::lang::XServiceInfo ),
DIRECT_INTERFACE( css::container::XNameAccess ),
DERIVED_INTERFACE( css::container::XElementAccess, css::container::XNameAccess )
)
DEFINE_XTYPEPROVIDER_4 ( UICommandDescription ,
css::lang::XTypeProvider ,
css::lang::XServiceInfo ,
css::container::XNameAccess ,
css::container::XElementAccess
)
DEFINE_XSERVICEINFO_ONEINSTANCESERVICE ( UICommandDescription ,
::cppu::OWeakObject ,
SERVICENAME_UICOMMANDDESCRIPTION ,
IMPLEMENTATIONNAME_UICOMMANDDESCRIPTION
)
DEFINE_INIT_SERVICE ( UICommandDescription, {} )
UICommandDescription::UICommandDescription( const Reference< XMultiServiceFactory >& xServiceManager ) :
ThreadHelpBase(),
m_aPrivateResourceURL( RTL_CONSTASCII_USTRINGPARAM( PRIVATE_RESOURCE_URL )),
m_xServiceManager( xServiceManager )
{
Reference< XNameAccess > xEmpty;
rtl::OUString aGenericUICommand( OUString::createFromAscii( "GenericCommands" ));
m_xGenericUICommands = new ConfigurationAccess_UICommand( aGenericUICommand, xEmpty, xServiceManager );
m_xModuleManager = Reference< XModuleManager >( m_xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ),
UNO_QUERY );
Reference< XNameAccess > xNameAccess( m_xModuleManager, UNO_QUERY_THROW );
Sequence< rtl::OUString > aElementNames = xNameAccess->getElementNames();
Sequence< PropertyValue > aSeq;
OUString aModuleIdentifier;
for ( sal_Int32 i = 0; i < aElementNames.getLength(); i++ )
{
aModuleIdentifier = aElementNames[i];
Any a = xNameAccess->getByName( aModuleIdentifier );
if ( a >>= aSeq )
{
OUString aCommandStr;
for ( sal_Int32 y = 0; y < aSeq.getLength(); y++ )
{
if ( aSeq[y].Name.equalsAscii("ooSetupFactoryCommandConfigRef") )
{
aSeq[y].Value >>= aCommandStr;
break;
}
}
// Create first mapping ModuleIdentifier ==> Command File
m_aModuleToCommandFileMap.insert( ModuleToCommandFileMap::value_type( aModuleIdentifier, aCommandStr ));
// Create second mapping Command File ==> commands instance
UICommandsHashMap::iterator pIter = m_aUICommandsHashMap.find( aCommandStr );
if ( pIter == m_aUICommandsHashMap.end() )
m_aUICommandsHashMap.insert( UICommandsHashMap::value_type( aCommandStr, Reference< XNameAccess >() ));
}
}
// insert generic commands
UICommandsHashMap::iterator pIter = m_aUICommandsHashMap.find( aGenericUICommand );
if ( pIter != m_aUICommandsHashMap.end() )
pIter->second = m_xGenericUICommands;
}
UICommandDescription::~UICommandDescription()
{
ResetableGuard aLock( m_aLock );
m_aModuleToCommandFileMap.clear();
m_aUICommandsHashMap.clear();
m_xGenericUICommands.clear();
}
Any SAL_CALL UICommandDescription::getByName( const ::rtl::OUString& aName )
throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException)
{
Any a;
ResetableGuard aLock( m_aLock );
ModuleToCommandFileMap::const_iterator pM2CIter = m_aModuleToCommandFileMap.find( aName );
if ( pM2CIter != m_aModuleToCommandFileMap.end() )
{
OUString aCommandFile( pM2CIter->second );
UICommandsHashMap::iterator pIter = m_aUICommandsHashMap.find( aCommandFile );
if ( pIter != m_aUICommandsHashMap.end() )
{
if ( pIter->second.is() )
a <<= pIter->second;
else
{
Reference< XNameAccess > xUICommands;
ConfigurationAccess_UICommand* pUICommands = new ConfigurationAccess_UICommand( aCommandFile,
m_xGenericUICommands,
m_xServiceManager );
xUICommands = Reference< XNameAccess >( static_cast< cppu::OWeakObject* >( pUICommands ),UNO_QUERY );
pIter->second = xUICommands;
a <<= xUICommands;
}
}
}
else if ( aName.indexOf( m_aPrivateResourceURL ) == 0 )
{
// special keys to retrieve information about a set of commands
return m_xGenericUICommands->getByName( aName );
}
else
{
throw NoSuchElementException();
}
return a;
}
Sequence< ::rtl::OUString > SAL_CALL UICommandDescription::getElementNames()
throw (::com::sun::star::uno::RuntimeException)
{
ResetableGuard aLock( m_aLock );
Sequence< rtl::OUString > aSeq( m_aModuleToCommandFileMap.size() );
sal_Int32 n = 0;
ModuleToCommandFileMap::const_iterator pIter = m_aModuleToCommandFileMap.begin();
while ( pIter != m_aModuleToCommandFileMap.end() )
{
aSeq[n] = pIter->first;
++pIter;
}
return aSeq;
}
sal_Bool SAL_CALL UICommandDescription::hasByName( const ::rtl::OUString& aName )
throw (::com::sun::star::uno::RuntimeException)
{
ResetableGuard aLock( m_aLock );
ModuleToCommandFileMap::const_iterator pIter = m_aModuleToCommandFileMap.find( aName );
return ( pIter != m_aModuleToCommandFileMap.end() );
}
// XElementAccess
Type SAL_CALL UICommandDescription::getElementType()
throw (::com::sun::star::uno::RuntimeException)
{
return( ::getCppuType( (const Reference< XNameAccess >*)NULL ) );
}
sal_Bool SAL_CALL UICommandDescription::hasElements()
throw (::com::sun::star::uno::RuntimeException)
{
// generic UI commands are always available!
return sal_True;
}
} // namespace framework
|
/*
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/modules/video_coding/packet_buffer.h"
#include <algorithm>
#include <limits>
#include <utility>
#include "webrtc/base/atomicops.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/modules/video_coding/frame_object.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
namespace video_coding {
rtc::scoped_refptr<PacketBuffer> PacketBuffer::Create(
Clock* clock,
size_t start_buffer_size,
size_t max_buffer_size,
OnReceivedFrameCallback* received_frame_callback) {
return rtc::scoped_refptr<PacketBuffer>(new PacketBuffer(
clock, start_buffer_size, max_buffer_size, received_frame_callback));
}
PacketBuffer::PacketBuffer(Clock* clock,
size_t start_buffer_size,
size_t max_buffer_size,
OnReceivedFrameCallback* received_frame_callback)
: clock_(clock),
size_(start_buffer_size),
max_size_(max_buffer_size),
first_seq_num_(0),
first_packet_received_(false),
is_cleared_to_first_seq_num_(false),
data_buffer_(start_buffer_size),
sequence_buffer_(start_buffer_size),
received_frame_callback_(received_frame_callback) {
RTC_DCHECK_LE(start_buffer_size, max_buffer_size);
// Buffer size must always be a power of 2.
RTC_DCHECK((start_buffer_size & (start_buffer_size - 1)) == 0);
RTC_DCHECK((max_buffer_size & (max_buffer_size - 1)) == 0);
}
PacketBuffer::~PacketBuffer() {
Clear();
}
bool PacketBuffer::InsertPacket(VCMPacket* packet) {
std::vector<std::unique_ptr<RtpFrameObject>> found_frames;
{
rtc::CritScope lock(&crit_);
uint16_t seq_num = packet->seqNum;
size_t index = seq_num % size_;
if (!first_packet_received_) {
first_seq_num_ = seq_num;
first_packet_received_ = true;
} else if (AheadOf(first_seq_num_, seq_num)) {
// If we have explicitly cleared past this packet then it's old,
// don't insert it.
if (is_cleared_to_first_seq_num_) {
delete[] packet->dataPtr;
packet->dataPtr = nullptr;
return false;
}
first_seq_num_ = seq_num;
}
if (sequence_buffer_[index].used) {
// Duplicate packet, just delete the payload.
if (data_buffer_[index].seqNum == packet->seqNum) {
delete[] packet->dataPtr;
packet->dataPtr = nullptr;
return true;
}
// The packet buffer is full, try to expand the buffer.
while (ExpandBufferSize() && sequence_buffer_[seq_num % size_].used) {
}
index = seq_num % size_;
// Packet buffer is still full.
if (sequence_buffer_[index].used) {
delete[] packet->dataPtr;
packet->dataPtr = nullptr;
return false;
}
}
sequence_buffer_[index].frame_begin = packet->is_first_packet_in_frame;
sequence_buffer_[index].frame_end = packet->markerBit;
sequence_buffer_[index].seq_num = packet->seqNum;
sequence_buffer_[index].continuous = false;
sequence_buffer_[index].frame_created = false;
sequence_buffer_[index].used = true;
data_buffer_[index] = *packet;
packet->dataPtr = nullptr;
found_frames = FindFrames(seq_num);
}
for (std::unique_ptr<RtpFrameObject>& frame : found_frames)
received_frame_callback_->OnReceivedFrame(std::move(frame));
return true;
}
void PacketBuffer::ClearTo(uint16_t seq_num) {
rtc::CritScope lock(&crit_);
// If the packet buffer was cleared between a frame was created and returned.
if (!first_packet_received_)
return;
is_cleared_to_first_seq_num_ = true;
while (AheadOrAt<uint16_t>(seq_num, first_seq_num_)) {
size_t index = first_seq_num_ % size_;
delete[] data_buffer_[index].dataPtr;
data_buffer_[index].dataPtr = nullptr;
sequence_buffer_[index].used = false;
++first_seq_num_;
}
}
void PacketBuffer::Clear() {
rtc::CritScope lock(&crit_);
for (size_t i = 0; i < size_; ++i) {
delete[] data_buffer_[i].dataPtr;
data_buffer_[i].dataPtr = nullptr;
sequence_buffer_[i].used = false;
}
first_packet_received_ = false;
is_cleared_to_first_seq_num_ = false;
}
bool PacketBuffer::ExpandBufferSize() {
if (size_ == max_size_) {
LOG(LS_WARNING) << "PacketBuffer is already at max size (" << max_size_
<< "), failed to increase size.";
return false;
}
size_t new_size = std::min(max_size_, 2 * size_);
std::vector<VCMPacket> new_data_buffer(new_size);
std::vector<ContinuityInfo> new_sequence_buffer(new_size);
for (size_t i = 0; i < size_; ++i) {
if (sequence_buffer_[i].used) {
size_t index = sequence_buffer_[i].seq_num % new_size;
new_sequence_buffer[index] = sequence_buffer_[i];
new_data_buffer[index] = data_buffer_[i];
}
}
size_ = new_size;
sequence_buffer_ = std::move(new_sequence_buffer);
data_buffer_ = std::move(new_data_buffer);
LOG(LS_INFO) << "PacketBuffer size expanded to " << new_size;
return true;
}
bool PacketBuffer::PotentialNewFrame(uint16_t seq_num) const {
size_t index = seq_num % size_;
int prev_index = index > 0 ? index - 1 : size_ - 1;
if (!sequence_buffer_[index].used)
return false;
if (sequence_buffer_[index].frame_created)
return false;
if (sequence_buffer_[index].frame_begin)
return true;
if (!sequence_buffer_[prev_index].used)
return false;
if (sequence_buffer_[prev_index].frame_created)
return false;
if (sequence_buffer_[prev_index].seq_num !=
static_cast<uint16_t>(sequence_buffer_[index].seq_num - 1)) {
return false;
}
if (sequence_buffer_[prev_index].continuous)
return true;
return false;
}
std::vector<std::unique_ptr<RtpFrameObject>> PacketBuffer::FindFrames(
uint16_t seq_num) {
std::vector<std::unique_ptr<RtpFrameObject>> found_frames;
size_t packets_tested = 0;
while (packets_tested < size_ && PotentialNewFrame(seq_num)) {
size_t index = seq_num % size_;
sequence_buffer_[index].continuous = true;
// If all packets of the frame is continuous, find the first packet of the
// frame and create an RtpFrameObject.
if (sequence_buffer_[index].frame_end) {
size_t frame_size = 0;
int max_nack_count = -1;
uint16_t start_seq_num = seq_num;
// Find the start index by searching backward until the packet with
// the |frame_begin| flag is set.
int start_index = index;
while (true) {
frame_size += data_buffer_[start_index].sizeBytes;
max_nack_count =
std::max(max_nack_count, data_buffer_[start_index].timesNacked);
sequence_buffer_[start_index].frame_created = true;
if (sequence_buffer_[start_index].frame_begin)
break;
start_index = start_index > 0 ? start_index - 1 : size_ - 1;
start_seq_num--;
}
found_frames.emplace_back(
new RtpFrameObject(this, start_seq_num, seq_num, frame_size,
max_nack_count, clock_->TimeInMilliseconds()));
}
++seq_num;
++packets_tested;
}
return found_frames;
}
void PacketBuffer::ReturnFrame(RtpFrameObject* frame) {
rtc::CritScope lock(&crit_);
size_t index = frame->first_seq_num() % size_;
size_t end = (frame->last_seq_num() + 1) % size_;
uint16_t seq_num = frame->first_seq_num();
while (index != end) {
if (sequence_buffer_[index].seq_num == seq_num) {
delete[] data_buffer_[index].dataPtr;
data_buffer_[index].dataPtr = nullptr;
sequence_buffer_[index].used = false;
}
index = (index + 1) % size_;
++seq_num;
}
}
bool PacketBuffer::GetBitstream(const RtpFrameObject& frame,
uint8_t* destination) {
rtc::CritScope lock(&crit_);
size_t index = frame.first_seq_num() % size_;
size_t end = (frame.last_seq_num() + 1) % size_;
uint16_t seq_num = frame.first_seq_num();
while (index != end) {
if (!sequence_buffer_[index].used ||
sequence_buffer_[index].seq_num != seq_num) {
return false;
}
const uint8_t* source = data_buffer_[index].dataPtr;
size_t length = data_buffer_[index].sizeBytes;
memcpy(destination, source, length);
destination += length;
index = (index + 1) % size_;
++seq_num;
}
return true;
}
VCMPacket* PacketBuffer::GetPacket(uint16_t seq_num) {
size_t index = seq_num % size_;
if (!sequence_buffer_[index].used ||
seq_num != sequence_buffer_[index].seq_num) {
return nullptr;
}
return &data_buffer_[index];
}
int PacketBuffer::AddRef() const {
return rtc::AtomicOps::Increment(&ref_count_);
}
int PacketBuffer::Release() const {
int count = rtc::AtomicOps::Decrement(&ref_count_);
if (!count) {
delete this;
}
return count;
}
} // namespace video_coding
} // namespace webrtc
video_coding::PacketBuffer now group all H264 packets with the same timestamp into the same frame.
Since we can't know when a H264 frame really starts we instead group all packets together by timestamp when a frame seems to be complete (only in the case of H264).
BUG=webrtc:5514
Review-Url: https://codereview.webrtc.org/2675693002
Cr-Commit-Position: 972c6d2dc6dd5efdad1377c0d224e03eb8f276f7@{#16419}
/*
* Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "webrtc/modules/video_coding/packet_buffer.h"
#include <algorithm>
#include <limits>
#include <utility>
#include "webrtc/base/atomicops.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/modules/video_coding/frame_object.h"
#include "webrtc/system_wrappers/include/clock.h"
namespace webrtc {
namespace video_coding {
rtc::scoped_refptr<PacketBuffer> PacketBuffer::Create(
Clock* clock,
size_t start_buffer_size,
size_t max_buffer_size,
OnReceivedFrameCallback* received_frame_callback) {
return rtc::scoped_refptr<PacketBuffer>(new PacketBuffer(
clock, start_buffer_size, max_buffer_size, received_frame_callback));
}
PacketBuffer::PacketBuffer(Clock* clock,
size_t start_buffer_size,
size_t max_buffer_size,
OnReceivedFrameCallback* received_frame_callback)
: clock_(clock),
size_(start_buffer_size),
max_size_(max_buffer_size),
first_seq_num_(0),
first_packet_received_(false),
is_cleared_to_first_seq_num_(false),
data_buffer_(start_buffer_size),
sequence_buffer_(start_buffer_size),
received_frame_callback_(received_frame_callback) {
RTC_DCHECK_LE(start_buffer_size, max_buffer_size);
// Buffer size must always be a power of 2.
RTC_DCHECK((start_buffer_size & (start_buffer_size - 1)) == 0);
RTC_DCHECK((max_buffer_size & (max_buffer_size - 1)) == 0);
}
PacketBuffer::~PacketBuffer() {
Clear();
}
bool PacketBuffer::InsertPacket(VCMPacket* packet) {
std::vector<std::unique_ptr<RtpFrameObject>> found_frames;
{
rtc::CritScope lock(&crit_);
uint16_t seq_num = packet->seqNum;
size_t index = seq_num % size_;
if (!first_packet_received_) {
first_seq_num_ = seq_num;
first_packet_received_ = true;
} else if (AheadOf(first_seq_num_, seq_num)) {
// If we have explicitly cleared past this packet then it's old,
// don't insert it.
if (is_cleared_to_first_seq_num_) {
delete[] packet->dataPtr;
packet->dataPtr = nullptr;
return false;
}
first_seq_num_ = seq_num;
}
if (sequence_buffer_[index].used) {
// Duplicate packet, just delete the payload.
if (data_buffer_[index].seqNum == packet->seqNum) {
delete[] packet->dataPtr;
packet->dataPtr = nullptr;
return true;
}
// The packet buffer is full, try to expand the buffer.
while (ExpandBufferSize() && sequence_buffer_[seq_num % size_].used) {
}
index = seq_num % size_;
// Packet buffer is still full.
if (sequence_buffer_[index].used) {
delete[] packet->dataPtr;
packet->dataPtr = nullptr;
return false;
}
}
sequence_buffer_[index].frame_begin = packet->is_first_packet_in_frame;
sequence_buffer_[index].frame_end = packet->markerBit;
sequence_buffer_[index].seq_num = packet->seqNum;
sequence_buffer_[index].continuous = false;
sequence_buffer_[index].frame_created = false;
sequence_buffer_[index].used = true;
data_buffer_[index] = *packet;
packet->dataPtr = nullptr;
found_frames = FindFrames(seq_num);
}
for (std::unique_ptr<RtpFrameObject>& frame : found_frames)
received_frame_callback_->OnReceivedFrame(std::move(frame));
return true;
}
void PacketBuffer::ClearTo(uint16_t seq_num) {
rtc::CritScope lock(&crit_);
// If the packet buffer was cleared between a frame was created and returned.
if (!first_packet_received_)
return;
is_cleared_to_first_seq_num_ = true;
while (AheadOrAt<uint16_t>(seq_num, first_seq_num_)) {
size_t index = first_seq_num_ % size_;
delete[] data_buffer_[index].dataPtr;
data_buffer_[index].dataPtr = nullptr;
sequence_buffer_[index].used = false;
++first_seq_num_;
}
}
void PacketBuffer::Clear() {
rtc::CritScope lock(&crit_);
for (size_t i = 0; i < size_; ++i) {
delete[] data_buffer_[i].dataPtr;
data_buffer_[i].dataPtr = nullptr;
sequence_buffer_[i].used = false;
}
first_packet_received_ = false;
is_cleared_to_first_seq_num_ = false;
}
bool PacketBuffer::ExpandBufferSize() {
if (size_ == max_size_) {
LOG(LS_WARNING) << "PacketBuffer is already at max size (" << max_size_
<< "), failed to increase size.";
return false;
}
size_t new_size = std::min(max_size_, 2 * size_);
std::vector<VCMPacket> new_data_buffer(new_size);
std::vector<ContinuityInfo> new_sequence_buffer(new_size);
for (size_t i = 0; i < size_; ++i) {
if (sequence_buffer_[i].used) {
size_t index = sequence_buffer_[i].seq_num % new_size;
new_sequence_buffer[index] = sequence_buffer_[i];
new_data_buffer[index] = data_buffer_[i];
}
}
size_ = new_size;
sequence_buffer_ = std::move(new_sequence_buffer);
data_buffer_ = std::move(new_data_buffer);
LOG(LS_INFO) << "PacketBuffer size expanded to " << new_size;
return true;
}
bool PacketBuffer::PotentialNewFrame(uint16_t seq_num) const {
size_t index = seq_num % size_;
int prev_index = index > 0 ? index - 1 : size_ - 1;
if (!sequence_buffer_[index].used)
return false;
if (sequence_buffer_[index].frame_created)
return false;
if (sequence_buffer_[index].frame_begin)
return true;
if (!sequence_buffer_[prev_index].used)
return false;
if (sequence_buffer_[prev_index].frame_created)
return false;
if (sequence_buffer_[prev_index].seq_num !=
static_cast<uint16_t>(sequence_buffer_[index].seq_num - 1)) {
return false;
}
if (sequence_buffer_[prev_index].continuous)
return true;
return false;
}
std::vector<std::unique_ptr<RtpFrameObject>> PacketBuffer::FindFrames(
uint16_t seq_num) {
std::vector<std::unique_ptr<RtpFrameObject>> found_frames;
size_t packets_tested = 0;
while (packets_tested < size_ && PotentialNewFrame(seq_num)) {
size_t index = seq_num % size_;
sequence_buffer_[index].continuous = true;
// If all packets of the frame is continuous, find the first packet of the
// frame and create an RtpFrameObject.
if (sequence_buffer_[index].frame_end) {
size_t frame_size = 0;
int max_nack_count = -1;
uint16_t start_seq_num = seq_num;
// Find the start index by searching backward until the packet with
// the |frame_begin| flag is set.
int start_index = index;
bool is_h264 = data_buffer_[start_index].codec == kVideoCodecH264;
int64_t frame_timestamp = data_buffer_[start_index].timestamp;
while (true) {
frame_size += data_buffer_[start_index].sizeBytes;
max_nack_count =
std::max(max_nack_count, data_buffer_[start_index].timesNacked);
sequence_buffer_[start_index].frame_created = true;
if (!is_h264 && sequence_buffer_[start_index].frame_begin)
break;
start_index = start_index > 0 ? start_index - 1 : size_ - 1;
// In the case of H264 we don't have a frame_begin bit (yes,
// |frame_begin| might be set to true but that is a lie). So instead
// we traverese backwards as long as we have a previous packet and
// the timestamp of that packet is the same as this one. This may cause
// the PacketBuffer to hand out incomplete frames.
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=7106
//
// Since we ignore the |frame_begin| flag of the inserted packets
// we check that |start_index != static_cast<int>(index)| to make sure
// that we don't get stuck in a loop if the packet buffer is filled
// with packets of the same timestamp.
if (is_h264 && start_index != static_cast<int>(index) &&
(!sequence_buffer_[start_index].used ||
data_buffer_[start_index].timestamp != frame_timestamp)) {
break;
}
--start_seq_num;
}
found_frames.emplace_back(
new RtpFrameObject(this, start_seq_num, seq_num, frame_size,
max_nack_count, clock_->TimeInMilliseconds()));
}
++seq_num;
++packets_tested;
}
return found_frames;
}
void PacketBuffer::ReturnFrame(RtpFrameObject* frame) {
rtc::CritScope lock(&crit_);
size_t index = frame->first_seq_num() % size_;
size_t end = (frame->last_seq_num() + 1) % size_;
uint16_t seq_num = frame->first_seq_num();
while (index != end) {
if (sequence_buffer_[index].seq_num == seq_num) {
delete[] data_buffer_[index].dataPtr;
data_buffer_[index].dataPtr = nullptr;
sequence_buffer_[index].used = false;
}
index = (index + 1) % size_;
++seq_num;
}
}
bool PacketBuffer::GetBitstream(const RtpFrameObject& frame,
uint8_t* destination) {
rtc::CritScope lock(&crit_);
size_t index = frame.first_seq_num() % size_;
size_t end = (frame.last_seq_num() + 1) % size_;
uint16_t seq_num = frame.first_seq_num();
while (index != end) {
if (!sequence_buffer_[index].used ||
sequence_buffer_[index].seq_num != seq_num) {
return false;
}
const uint8_t* source = data_buffer_[index].dataPtr;
size_t length = data_buffer_[index].sizeBytes;
memcpy(destination, source, length);
destination += length;
index = (index + 1) % size_;
++seq_num;
}
return true;
}
VCMPacket* PacketBuffer::GetPacket(uint16_t seq_num) {
size_t index = seq_num % size_;
if (!sequence_buffer_[index].used ||
seq_num != sequence_buffer_[index].seq_num) {
return nullptr;
}
return &data_buffer_[index];
}
int PacketBuffer::AddRef() const {
return rtc::AtomicOps::Increment(&ref_count_);
}
int PacketBuffer::Release() const {
int count = rtc::AtomicOps::Decrement(&ref_count_);
if (!count) {
delete this;
}
return count;
}
} // namespace video_coding
} // namespace webrtc
|
/**************************************************************************
* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
////////////////////////////////////////////////////////////
//This class contains the methods to create raw data //
//for CTP (trigger). The CTP data format is taken as //
//described in the Trigger TDR - pages 134 and 135. //
//The updated version of raw data is in: //
//http://epweb2.ph.bham.ac.uk/user/krivda/alice/ctp/ctp_readout1.pdf//
//////////////////////////////////////////////////////////
#include <TObject.h>
#include <TString.h>
#include <Riostream.h>
#include "AliCTPRawData.h"
#include "AliRunLoader.h"
#include "AliCentralTrigger.h"
#include "AliRawDataHeaderSim.h"
#include "AliLog.h"
#include "AliDAQ.h"
#include "AliFstream.h"
ClassImp(AliCTPRawData)
////////////////////////////////////////////////////////////////////////////////////////
//______________________________________________________________________________
AliCTPRawData::AliCTPRawData()
{
// Default constructor
}
//______________________________________________________________________________
AliCTPRawData::AliCTPRawData(const AliCTPRawData &source):
TObject(source)
{
// Copy Constructor
}
//______________________________________________________________________________
AliCTPRawData& AliCTPRawData::operator=(const AliCTPRawData &source)
{
// Assigment operator
if(this==&source) return *this;
((TObject *)this)->operator=(source);
return *this;
}
//______________________________________________________________________________
void AliCTPRawData::RawData()
{
// This method writes the CTP (trigger)
// raw data in a DDL file
ULong64_t l2class = 0;
UChar_t l2cluster = 0;
UInt_t l0input = 0;
UInt_t l1input = 0;
UShort_t l2input=0;
AliInfo("Storing the CTP DDL raw data...");
AliRunLoader *runloader = AliRunLoader::Instance();
if (runloader) {
if (!runloader->LoadTrigger()) {
AliCentralTrigger *aCTP = runloader->GetTrigger();
if (AliDebugLevel() > 0)
aCTP->Dump();
// First get the trigger mask
l2class = aCTP->GetClassMask();
// Then get the detector cluster to be read out
l2cluster = aCTP->GetClusterMask();
// Then get the input cluster mask
l0input = aCTP->GetL0TriggerInputs();
l1input = aCTP->GetL1TriggerInputs();
l2input = aCTP->GetL2TriggerInputs();
}
else
AliWarning("No trigger can be loaded! Putting empty trigger class into the CTP raw data !");
}
else
AliError("No run loader is available! Putting empty trigger class into the CTP raw data !");
AliDebug(1,Form("CTP trigger mask = 0x%llx",l2class));
AliDebug(1,Form("CTP detector cluster = 0x%x",l2cluster));
char fileName[15];
strcpy(fileName,AliDAQ::DdlFileName("TRG",0));
AliInfo(Form("Storing CTP raw data in %s",fileName));
AliFstream* outfile; // logical name of the output file
outfile = new AliFstream(fileName);
// Writing CTP raw data here
// The format is taken as in
// dhttp://epweb2.ph.bham.ac.uk/user/krivda/alice/ctp/ctp_readout1.pdf
// If not 0, from where??
UInt_t bunchCross = 0;
UInt_t orbitId = 0;
Bool_t esr = 0; // Enable Segmented Readout flag
// First 3 words here - Bunch-crossing and orbit numbers
UInt_t word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= bunchCross & 0xFFF;
AliDebug(1,Form("CTP word1 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (orbitId >> 12) & 0xFFF;
AliDebug(1,Form("CTP word2 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= orbitId & 0xFFF;
AliDebug(1,Form("CTP word3 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
// Now the 4th word
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= ((UInt_t)esr) << 10;
word |= 0 << 8; // L2SwC - physics trigger
word |= (l2cluster & 0x3F) << 2; // L2Cluster
word |= (UInt_t)((l2class >> 48) & 0x3);
AliDebug(1,Form("CTP word4 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
// Then the 4 words with the trigger classes
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2class >> 36) & 0xFFF);
AliDebug(1,Form("CTP word5 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2class >> 24) & 0xFFF);
AliDebug(1,Form("CTP word6 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2class >> 12) & 0xFFF);
AliDebug(1,Form("CTP word7 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)(l2class & 0xFFF);
AliDebug(1,Form("CTP word8 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
// The last 5 words with trigger inputs
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l0input >> 12) & 0xFFF);
AliDebug(1,Form("CTP word9 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l0input >> 0) & 0xFFF);
AliDebug(1,Form("CTP word10 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l1input >> 12) & 0xFFF);
AliDebug(1,Form("CTP word11 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l1input >> 0) & 0xFFF);
AliDebug(1,Form("CTP word12 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2input >> 0) & 0xFFF);
AliDebug(1,Form("CTP word13 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
delete outfile;
return;
}
Coverity defect fixed.
/**************************************************************************
* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
////////////////////////////////////////////////////////////
//This class contains the methods to create raw data //
//for CTP (trigger). The CTP data format is taken as //
//described in the Trigger TDR - pages 134 and 135. //
//The updated version of raw data is in: //
//http://epweb2.ph.bham.ac.uk/user/krivda/alice/ctp/ctp_readout1.pdf//
//////////////////////////////////////////////////////////
#include <TObject.h>
#include <TString.h>
#include <Riostream.h>
#include "AliCTPRawData.h"
#include "AliRunLoader.h"
#include "AliCentralTrigger.h"
#include "AliRawDataHeaderSim.h"
#include "AliLog.h"
#include "AliDAQ.h"
#include "AliFstream.h"
ClassImp(AliCTPRawData)
////////////////////////////////////////////////////////////////////////////////////////
//______________________________________________________________________________
AliCTPRawData::AliCTPRawData()
{
// Default constructor
}
//______________________________________________________________________________
AliCTPRawData::AliCTPRawData(const AliCTPRawData &source):
TObject(source)
{
// Copy Constructor
}
//______________________________________________________________________________
AliCTPRawData& AliCTPRawData::operator=(const AliCTPRawData &source)
{
// Assigment operator
if(this==&source) return *this;
((TObject *)this)->operator=(source);
return *this;
}
//______________________________________________________________________________
void AliCTPRawData::RawData()
{
// This method writes the CTP (trigger)
// raw data in a DDL file
ULong64_t l2class = 0;
UChar_t l2cluster = 0;
UInt_t l0input = 0;
UInt_t l1input = 0;
UShort_t l2input=0;
AliInfo("Storing the CTP DDL raw data...");
AliRunLoader *runloader = AliRunLoader::Instance();
if (runloader) {
if (!runloader->LoadTrigger()) {
AliCentralTrigger *aCTP = runloader->GetTrigger();
if (AliDebugLevel() > 0)
aCTP->Dump();
// First get the trigger mask
l2class = aCTP->GetClassMask();
// Then get the detector cluster to be read out
l2cluster = aCTP->GetClusterMask();
// Then get the input cluster mask
l0input = aCTP->GetL0TriggerInputs();
l1input = aCTP->GetL1TriggerInputs();
l2input = aCTP->GetL2TriggerInputs();
}
else
AliWarning("No trigger can be loaded! Putting empty trigger class into the CTP raw data !");
}
else
AliError("No run loader is available! Putting empty trigger class into the CTP raw data !");
AliDebug(1,Form("CTP trigger mask = 0x%llx",l2class));
AliDebug(1,Form("CTP detector cluster = 0x%x",l2cluster));
TString fileName = AliDAQ::DdlFileName("TRG",0);
AliInfo(Form("Storing CTP raw data in %s",fileName.Data()));
AliFstream* outfile; // logical name of the output file
outfile = new AliFstream(fileName.Data());
// Writing CTP raw data here
// The format is taken as in
// dhttp://epweb2.ph.bham.ac.uk/user/krivda/alice/ctp/ctp_readout1.pdf
// If not 0, from where??
UInt_t bunchCross = 0;
UInt_t orbitId = 0;
Bool_t esr = 0; // Enable Segmented Readout flag
// First 3 words here - Bunch-crossing and orbit numbers
UInt_t word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= bunchCross & 0xFFF;
AliDebug(1,Form("CTP word1 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (orbitId >> 12) & 0xFFF;
AliDebug(1,Form("CTP word2 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= orbitId & 0xFFF;
AliDebug(1,Form("CTP word3 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
// Now the 4th word
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= ((UInt_t)esr) << 10;
word |= 0 << 8; // L2SwC - physics trigger
word |= (l2cluster & 0x3F) << 2; // L2Cluster
word |= (UInt_t)((l2class >> 48) & 0x3);
AliDebug(1,Form("CTP word4 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
// Then the 4 words with the trigger classes
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2class >> 36) & 0xFFF);
AliDebug(1,Form("CTP word5 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2class >> 24) & 0xFFF);
AliDebug(1,Form("CTP word6 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2class >> 12) & 0xFFF);
AliDebug(1,Form("CTP word7 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)(l2class & 0xFFF);
AliDebug(1,Form("CTP word8 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
// The last 5 words with trigger inputs
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l0input >> 12) & 0xFFF);
AliDebug(1,Form("CTP word9 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l0input >> 0) & 0xFFF);
AliDebug(1,Form("CTP word10 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l1input >> 12) & 0xFFF);
AliDebug(1,Form("CTP word11 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l1input >> 0) & 0xFFF);
AliDebug(1,Form("CTP word12 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
word = 0;
word |= 0 << 15; // BlockID = 0 in case of CTP readout
word |= (UInt_t)((l2input >> 0) & 0xFFF);
AliDebug(1,Form("CTP word13 = 0x%x",word));
outfile->WriteBuffer((char*)(&word),sizeof(UInt_t));
delete outfile;
return;
}
|
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) Lewis Baker
// Licenced under MIT license. See LICENSE.txt for details.
///////////////////////////////////////////////////////////////////////////////
#include <cppcoro/when_all.hpp>
#include <cppcoro/config.hpp>
#include <cppcoro/async_manual_reset_event.hpp>
#include <cppcoro/async_mutex.hpp>
#include <cppcoro/fmap.hpp>
#include <cppcoro/shared_task.hpp>
#include <cppcoro/sync_wait.hpp>
#include <cppcoro/task.hpp>
#include "counted.hpp"
#include <functional>
#include <string>
#include <vector>
#include <ostream>
#include "doctest/doctest.h"
TEST_SUITE_BEGIN("when_all");
namespace
{
template<template<typename T> class TASK, typename T>
TASK<T> when_event_set_return(cppcoro::async_manual_reset_event& event, T value)
{
co_await event;
co_return std::move(value);
}
}
TEST_CASE("when_all() with no args completes immediately")
{
[[maybe_unused]] std::tuple<> result = cppcoro::sync_wait(cppcoro::when_all());
}
TEST_CASE("when_all() with one arg")
{
bool started = false;
bool finished = false;
auto f = [&](cppcoro::async_manual_reset_event& event) -> cppcoro::task<std::string>
{
started = true;
co_await event;
finished = true;
co_return "foo";
};
cppcoro::async_manual_reset_event event;
auto whenAllTask = cppcoro::when_all(f(event));
CHECK(!started);
cppcoro::sync_wait(cppcoro::when_all_ready(
[&]() -> cppcoro::task<>
{
auto[s] = co_await whenAllTask;
CHECK(s == "foo");
}(),
[&]() -> cppcoro::task<>
{
CHECK(started);
CHECK(!finished);
event.set();
CHECK(finished);
co_return;
}()));
}
TEST_CASE("when_all() with awaitables")
{
cppcoro::sync_wait([]() -> cppcoro::task<>
{
auto makeTask = [](int x) -> cppcoro::task<int>
{
co_return x;
};
cppcoro::async_manual_reset_event event;
event.set();
cppcoro::async_mutex mutex;
auto[eventResult, mutexLock, number] = co_await cppcoro::when_all(
std::ref(event),
mutex.scoped_lock_async(),
makeTask(123) | cppcoro::fmap([](int x) { return x + 1; }));
(void)eventResult;
(void)mutexLock;
CHECK(number == 124);
CHECK(!mutex.try_lock());
}());
}
TEST_CASE("when_all() with all task types")
{
counted::reset_counts();
auto run = [](cppcoro::async_manual_reset_event& event) -> cppcoro::task<>
{
using namespace std::string_literals;
auto[a, b] = co_await cppcoro::when_all(
when_event_set_return<cppcoro::task>(event, "foo"s),
when_event_set_return<cppcoro::shared_task>(event, counted{}));
CHECK(a == "foo");
CHECK(b.id == 0);
CHECK(counted::active_count() == 1);
};
cppcoro::async_manual_reset_event event;
cppcoro::sync_wait(cppcoro::when_all_ready(
run(event),
[&]() -> cppcoro::task<>
{
event.set();
co_return;
}()));
}
TEST_CASE("when_all() throws if any task throws")
{
struct X {};
struct Y {};
int startedCount = 0;
auto makeTask = [&](int value) -> cppcoro::task<int>
{
++startedCount;
if (value == 0) throw X{};
else if (value == 1) throw Y{};
else co_return value;
};
cppcoro::sync_wait([&]() -> cppcoro::task<>
{
try
{
// This could either throw X or Y exception.
// The exact exception that is thrown is not defined if multiple tasks throw an exception.
// TODO: Consider throwing some kind of aggregate_exception that collects all of the exceptions together.
(void)co_await cppcoro::when_all(makeTask(0), makeTask(1), makeTask(2));
}
catch (const X&)
{
}
catch (const Y&)
{
}
}());
}
TEST_CASE("when_all() with task<void>")
{
int voidTaskCount = 0;
auto makeVoidTask = [&]() -> cppcoro::task<>
{
++voidTaskCount;
co_return;
};
auto makeIntTask = [](int x) -> cppcoro::task<int>
{
co_return x;
};
// Single void task in when_all()
auto[x] = cppcoro::sync_wait(cppcoro::when_all(makeVoidTask()));
(void)x;
CHECK(voidTaskCount == 1);
// Multiple void tasks in when_all()
auto[a, b] = cppcoro::sync_wait(cppcoro::when_all(
makeVoidTask(),
makeVoidTask()));
(void)a;
(void)b;
CHECK(voidTaskCount == 3);
// Mixing void and non-void tasks in when_all()
auto[v1, i, v2] = cppcoro::sync_wait(cppcoro::when_all(
makeVoidTask(),
makeIntTask(123),
makeVoidTask()));
(void)v1;
(void)v2;
CHECK(voidTaskCount == 5);
CHECK(i == 123);
}
TEST_CASE("when_all() with vector<task<>>")
{
int startedCount = 0;
auto makeTask = [&](cppcoro::async_manual_reset_event& event) -> cppcoro::task<>
{
++startedCount;
co_await event;
};
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
bool finished = false;
auto run = [&]() -> cppcoro::task<>
{
std::vector<cppcoro::task<>> tasks;
tasks.push_back(makeTask(event1));
tasks.push_back(makeTask(event2));
tasks.push_back(makeTask(event1));
auto allTask = cppcoro::when_all(std::move(tasks));
CHECK(startedCount == 0);
co_await allTask;
finished = true;
};
cppcoro::sync_wait(cppcoro::when_all_ready(
run(),
[&]() -> cppcoro::task<>
{
CHECK(startedCount == 3);
CHECK(!finished);
event1.set();
CHECK(!finished);
event2.set();
CHECK(finished);
co_return;
}()));
}
TEST_CASE("when_all() with vector<shared_task<>>")
{
int startedCount = 0;
auto makeTask = [&](cppcoro::async_manual_reset_event& event) -> cppcoro::shared_task<>
{
++startedCount;
co_await event;
};
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
bool finished = false;
auto run = [&]() -> cppcoro::task<>
{
std::vector<cppcoro::shared_task<>> tasks;
tasks.push_back(makeTask(event1));
tasks.push_back(makeTask(event2));
tasks.push_back(makeTask(event1));
auto allTask = cppcoro::when_all(std::move(tasks));
CHECK(startedCount == 0);
co_await allTask;
finished = true;
};
cppcoro::sync_wait(cppcoro::when_all_ready(
run(),
[&]() -> cppcoro::task<>
{
CHECK(startedCount == 3);
CHECK(!finished);
event1.set();
CHECK(!finished);
event2.set();
CHECK(finished);
co_return;
}()));
}
namespace
{
template<template<typename T> class TASK>
void check_when_all_vector_of_task_value()
{
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
bool whenAllCompleted = false;
cppcoro::sync_wait(cppcoro::when_all_ready(
[&]() -> cppcoro::task<>
{
std::vector<TASK<int>> tasks;
tasks.emplace_back(when_event_set_return<TASK>(event1, 1));
tasks.emplace_back(when_event_set_return<TASK>(event2, 2));
auto whenAllTask = cppcoro::when_all(std::move(tasks));
auto values = co_await whenAllTask;
REQUIRE(values.size() == 2);
CHECK(values[0] == 1);
CHECK(values[1] == 2);
whenAllCompleted = true;
}(),
[&]() -> cppcoro::task<>
{
CHECK(!whenAllCompleted);
event2.set();
CHECK(!whenAllCompleted);
event1.set();
CHECK(whenAllCompleted);
co_return;
}()));
}
}
TEST_CASE("when_all() with vector<task<T>>")
{
check_when_all_vector_of_task_value<cppcoro::task>();
}
#if defined(CPPCORO_RELEASE_OPTIMISED)
constexpr bool isOptimised = true;
#else
constexpr bool isOptimised = false;
#endif
// Disable test on MSVC x64 optimised due to bad codegen bug in
// 'co_await whenAllTask' expression.
// Issue reported to MS on 19/11/2017.
TEST_CASE("when_all() with vector<shared_task<T>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191225805 &&
isOptimised && CPPCORO_CPU_X64))
{
check_when_all_vector_of_task_value<cppcoro::shared_task>();
}
namespace
{
template<template<typename T> class TASK>
void check_when_all_vector_of_task_reference()
{
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
int value1 = 1;
int value2 = 2;
auto makeTask = [](cppcoro::async_manual_reset_event& event, int& value) -> TASK<int&>
{
co_await event;
co_return value;
};
bool whenAllComplete = false;
cppcoro::sync_wait(cppcoro::when_all_ready(
[&]() -> cppcoro::task<>
{
std::vector<TASK<int&>> tasks;
tasks.emplace_back(makeTask(event1, value1));
tasks.emplace_back(makeTask(event2, value2));
auto whenAllTask = cppcoro::when_all(std::move(tasks));
std::vector<std::reference_wrapper<int>> values = co_await whenAllTask;
REQUIRE(values.size() == 2);
CHECK(&values[0].get() == &value1);
CHECK(&values[1].get() == &value2);
whenAllComplete = true;
}(),
[&]() -> cppcoro::task<>
{
CHECK(!whenAllComplete);
event2.set();
CHECK(!whenAllComplete);
event1.set();
CHECK(whenAllComplete);
co_return;
}()));
}
}
// Disable test on MSVC x64 optimised due to bad codegen bug in
// 'co_await whenAllTask' expression.
// Issue reported to MS on 19/11/2017.
TEST_CASE("when_all() with vector<task<T&>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191225805 &&
isOptimised && CPPCORO_CPU_X64))
{
check_when_all_vector_of_task_reference<cppcoro::task>();
}
// Disable test on MSVC x64 optimised due to bad codegen bug in
// 'co_await whenAllTask' expression.
// Issue reported to MS on 19/11/2017.
TEST_CASE("when_all() with vector<shared_task<T&>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191225805 &&
isOptimised && CPPCORO_CPU_X64))
{
check_when_all_vector_of_task_reference<cppcoro::shared_task>();
}
TEST_SUITE_END();
Skip failing when_all() test on msvc x86 optimised.
It seems to be failing due to an msvc compiler bug.
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) Lewis Baker
// Licenced under MIT license. See LICENSE.txt for details.
///////////////////////////////////////////////////////////////////////////////
#include <cppcoro/when_all.hpp>
#include <cppcoro/config.hpp>
#include <cppcoro/async_manual_reset_event.hpp>
#include <cppcoro/async_mutex.hpp>
#include <cppcoro/fmap.hpp>
#include <cppcoro/shared_task.hpp>
#include <cppcoro/sync_wait.hpp>
#include <cppcoro/task.hpp>
#include "counted.hpp"
#include <functional>
#include <string>
#include <vector>
#include <ostream>
#include "doctest/doctest.h"
TEST_SUITE_BEGIN("when_all");
namespace
{
template<template<typename T> class TASK, typename T>
TASK<T> when_event_set_return(cppcoro::async_manual_reset_event& event, T value)
{
co_await event;
co_return std::move(value);
}
}
TEST_CASE("when_all() with no args completes immediately")
{
[[maybe_unused]] std::tuple<> result = cppcoro::sync_wait(cppcoro::when_all());
}
TEST_CASE("when_all() with one arg")
{
bool started = false;
bool finished = false;
auto f = [&](cppcoro::async_manual_reset_event& event) -> cppcoro::task<std::string>
{
started = true;
co_await event;
finished = true;
co_return "foo";
};
cppcoro::async_manual_reset_event event;
auto whenAllTask = cppcoro::when_all(f(event));
CHECK(!started);
cppcoro::sync_wait(cppcoro::when_all_ready(
[&]() -> cppcoro::task<>
{
auto[s] = co_await whenAllTask;
CHECK(s == "foo");
}(),
[&]() -> cppcoro::task<>
{
CHECK(started);
CHECK(!finished);
event.set();
CHECK(finished);
co_return;
}()));
}
TEST_CASE("when_all() with awaitables")
{
cppcoro::sync_wait([]() -> cppcoro::task<>
{
auto makeTask = [](int x) -> cppcoro::task<int>
{
co_return x;
};
cppcoro::async_manual_reset_event event;
event.set();
cppcoro::async_mutex mutex;
auto[eventResult, mutexLock, number] = co_await cppcoro::when_all(
std::ref(event),
mutex.scoped_lock_async(),
makeTask(123) | cppcoro::fmap([](int x) { return x + 1; }));
(void)eventResult;
(void)mutexLock;
CHECK(number == 124);
CHECK(!mutex.try_lock());
}());
}
TEST_CASE("when_all() with all task types")
{
counted::reset_counts();
auto run = [](cppcoro::async_manual_reset_event& event) -> cppcoro::task<>
{
using namespace std::string_literals;
auto[a, b] = co_await cppcoro::when_all(
when_event_set_return<cppcoro::task>(event, "foo"s),
when_event_set_return<cppcoro::shared_task>(event, counted{}));
CHECK(a == "foo");
CHECK(b.id == 0);
CHECK(counted::active_count() == 1);
};
cppcoro::async_manual_reset_event event;
cppcoro::sync_wait(cppcoro::when_all_ready(
run(event),
[&]() -> cppcoro::task<>
{
event.set();
co_return;
}()));
}
TEST_CASE("when_all() throws if any task throws")
{
struct X {};
struct Y {};
int startedCount = 0;
auto makeTask = [&](int value) -> cppcoro::task<int>
{
++startedCount;
if (value == 0) throw X{};
else if (value == 1) throw Y{};
else co_return value;
};
cppcoro::sync_wait([&]() -> cppcoro::task<>
{
try
{
// This could either throw X or Y exception.
// The exact exception that is thrown is not defined if multiple tasks throw an exception.
// TODO: Consider throwing some kind of aggregate_exception that collects all of the exceptions together.
(void)co_await cppcoro::when_all(makeTask(0), makeTask(1), makeTask(2));
}
catch (const X&)
{
}
catch (const Y&)
{
}
}());
}
TEST_CASE("when_all() with task<void>")
{
int voidTaskCount = 0;
auto makeVoidTask = [&]() -> cppcoro::task<>
{
++voidTaskCount;
co_return;
};
auto makeIntTask = [](int x) -> cppcoro::task<int>
{
co_return x;
};
// Single void task in when_all()
auto[x] = cppcoro::sync_wait(cppcoro::when_all(makeVoidTask()));
(void)x;
CHECK(voidTaskCount == 1);
// Multiple void tasks in when_all()
auto[a, b] = cppcoro::sync_wait(cppcoro::when_all(
makeVoidTask(),
makeVoidTask()));
(void)a;
(void)b;
CHECK(voidTaskCount == 3);
// Mixing void and non-void tasks in when_all()
auto[v1, i, v2] = cppcoro::sync_wait(cppcoro::when_all(
makeVoidTask(),
makeIntTask(123),
makeVoidTask()));
(void)v1;
(void)v2;
CHECK(voidTaskCount == 5);
CHECK(i == 123);
}
TEST_CASE("when_all() with vector<task<>>")
{
int startedCount = 0;
auto makeTask = [&](cppcoro::async_manual_reset_event& event) -> cppcoro::task<>
{
++startedCount;
co_await event;
};
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
bool finished = false;
auto run = [&]() -> cppcoro::task<>
{
std::vector<cppcoro::task<>> tasks;
tasks.push_back(makeTask(event1));
tasks.push_back(makeTask(event2));
tasks.push_back(makeTask(event1));
auto allTask = cppcoro::when_all(std::move(tasks));
CHECK(startedCount == 0);
co_await allTask;
finished = true;
};
cppcoro::sync_wait(cppcoro::when_all_ready(
run(),
[&]() -> cppcoro::task<>
{
CHECK(startedCount == 3);
CHECK(!finished);
event1.set();
CHECK(!finished);
event2.set();
CHECK(finished);
co_return;
}()));
}
TEST_CASE("when_all() with vector<shared_task<>>")
{
int startedCount = 0;
auto makeTask = [&](cppcoro::async_manual_reset_event& event) -> cppcoro::shared_task<>
{
++startedCount;
co_await event;
};
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
bool finished = false;
auto run = [&]() -> cppcoro::task<>
{
std::vector<cppcoro::shared_task<>> tasks;
tasks.push_back(makeTask(event1));
tasks.push_back(makeTask(event2));
tasks.push_back(makeTask(event1));
auto allTask = cppcoro::when_all(std::move(tasks));
CHECK(startedCount == 0);
co_await allTask;
finished = true;
};
cppcoro::sync_wait(cppcoro::when_all_ready(
run(),
[&]() -> cppcoro::task<>
{
CHECK(startedCount == 3);
CHECK(!finished);
event1.set();
CHECK(!finished);
event2.set();
CHECK(finished);
co_return;
}()));
}
namespace
{
template<template<typename T> class TASK>
void check_when_all_vector_of_task_value()
{
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
bool whenAllCompleted = false;
cppcoro::sync_wait(cppcoro::when_all_ready(
[&]() -> cppcoro::task<>
{
std::vector<TASK<int>> tasks;
tasks.emplace_back(when_event_set_return<TASK>(event1, 1));
tasks.emplace_back(when_event_set_return<TASK>(event2, 2));
auto whenAllTask = cppcoro::when_all(std::move(tasks));
auto values = co_await whenAllTask;
REQUIRE(values.size() == 2);
CHECK(values[0] == 1);
CHECK(values[1] == 2);
whenAllCompleted = true;
}(),
[&]() -> cppcoro::task<>
{
CHECK(!whenAllCompleted);
event2.set();
CHECK(!whenAllCompleted);
event1.set();
CHECK(whenAllCompleted);
co_return;
}()));
}
}
#if defined(CPPCORO_RELEASE_OPTIMISED)
constexpr bool isOptimised = true;
#else
constexpr bool isOptimised = false;
#endif
// Disable test on MSVC x86 optimised due to bad codegen bug in
// `co_await whenAllTask` expression under MSVC 15.7 (Preview 2) and earlier.
TEST_CASE("when_all() with vector<task<T>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191426316 && CPPCORO_CPU_X86 && isOptimised))
{
check_when_all_vector_of_task_value<cppcoro::task>();
}
// Disable test on MSVC x64 optimised due to bad codegen bug in
// 'co_await whenAllTask' expression.
// Issue reported to MS on 19/11/2017.
TEST_CASE("when_all() with vector<shared_task<T>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191225805 &&
isOptimised && CPPCORO_CPU_X64))
{
check_when_all_vector_of_task_value<cppcoro::shared_task>();
}
namespace
{
template<template<typename T> class TASK>
void check_when_all_vector_of_task_reference()
{
cppcoro::async_manual_reset_event event1;
cppcoro::async_manual_reset_event event2;
int value1 = 1;
int value2 = 2;
auto makeTask = [](cppcoro::async_manual_reset_event& event, int& value) -> TASK<int&>
{
co_await event;
co_return value;
};
bool whenAllComplete = false;
cppcoro::sync_wait(cppcoro::when_all_ready(
[&]() -> cppcoro::task<>
{
std::vector<TASK<int&>> tasks;
tasks.emplace_back(makeTask(event1, value1));
tasks.emplace_back(makeTask(event2, value2));
auto whenAllTask = cppcoro::when_all(std::move(tasks));
std::vector<std::reference_wrapper<int>> values = co_await whenAllTask;
REQUIRE(values.size() == 2);
CHECK(&values[0].get() == &value1);
CHECK(&values[1].get() == &value2);
whenAllComplete = true;
}(),
[&]() -> cppcoro::task<>
{
CHECK(!whenAllComplete);
event2.set();
CHECK(!whenAllComplete);
event1.set();
CHECK(whenAllComplete);
co_return;
}()));
}
}
// Disable test on MSVC x64 optimised due to bad codegen bug in
// 'co_await whenAllTask' expression.
// Issue reported to MS on 19/11/2017.
TEST_CASE("when_all() with vector<task<T&>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191225805 &&
isOptimised && CPPCORO_CPU_X64))
{
check_when_all_vector_of_task_reference<cppcoro::task>();
}
// Disable test on MSVC x64 optimised due to bad codegen bug in
// 'co_await whenAllTask' expression.
// Issue reported to MS on 19/11/2017.
TEST_CASE("when_all() with vector<shared_task<T&>>"
* doctest::skip(CPPCORO_COMPILER_MSVC && CPPCORO_COMPILER_MSVC <= 191225805 &&
isOptimised && CPPCORO_CPU_X64))
{
check_when_all_vector_of_task_reference<cppcoro::shared_task>();
}
TEST_SUITE_END();
|
//
// ofxRemoteUI.cpp
// emptyExample
//
// Created by Oriol Ferrer Mesià on 09/01/13.
//
//
#ifdef TARGET_WIN32
#include <winsock2.h>
#endif
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#ifdef __APPLE__
#include "dirent.h"
#include <mach-o/dyld.h> /* _NSGetExecutablePath */
#elif _WIN32 || _WIN64
#include "dirent_vs.h"
#endif
#include <sys/stat.h>
#include <time.h>
#include "ofxRemoteUIServer.h"
#ifdef OF_AVAILABLE
#include <Poco/Path.h>
#include <Poco/Environment.h>
#include <Poco/Process.h>
#include <Poco/Util/Application.h>
using Poco::Util::Application;
#endif
ofxRemoteUIServer* ofxRemoteUIServer::singleton = NULL;
ofxRemoteUIServer* ofxRemoteUIServer::instance(){
if (!singleton){ // Only allow one instance of class to be generated.
singleton = new ofxRemoteUIServer();
}
return singleton;
}
void ofxRemoteUIServer::setEnabled(bool enabled_){
enabled = enabled_;
}
void ofxRemoteUIServer::setAutomaticBackupsEnabled(bool enabled){
autoBackups = enabled;
}
void ofxRemoteUIServer::setDrawsNotificationsAutomaticallly(bool draw){
drawNotifications = draw;
}
void ofxRemoteUIServer::setShowInterfaceKey(char k){
showInterfaceKey = k;
}
ofxRemoteUIServer::ofxRemoteUIServer(){
enabled = true;
readyToSend = false;
saveToXmlOnExit = true;
autoBackups = false; //off by default
broadcastTime = OFXREMOTEUI_BORADCAST_INTERVAL + 0.05;
timeSinceLastReply = avgTimeSinceLastReply = 0;
waitingForReply = false;
colorSet = false;
computerName = binaryName = "";
directoryPrefix = "";
callBack = NULL;
upcomingGroup = OFXREMOTEUI_DEFAULT_PARAM_GROUP;
verbose_ = false;
threadedUpdate = false;
drawNotifications = true;
showUI = false;
loadedFromXML = false;
clearXmlOnSaving = false;
//add random colors to table
colorTableIndex = 0;
broadcastCount = 0;
newColorInGroupCounter = 1;
showInterfaceKey = '\t';
int a = 80;
#ifdef OF_AVAILABLE
uiColumnWidth = 320;
uiAlpha = 1.0f;
selectedPreset = selectedGroupPreset = 0;
selectedItem = -1;
ofSeedRandom(1979);
ofColor prevColor = ofColor::fromHsb(35, 255, 200, BG_COLOR_ALPHA);
for(int i = 0; i < 30; i++){
ofColor c = ofColor::fromHsb(prevColor.getHue() + 10, 255, 210, BG_COLOR_ALPHA);
colorTables.push_back( c );
prevColor = c;
}
//shuffle
std::srand(1979);
std::random_shuffle ( colorTables.begin(), colorTables.end() );
ofSeedRandom();
uiLines.setMode(OF_PRIMITIVE_LINES);
#else
colorTables.push_back(ofColor(194,144,221,a) );
colorTables.push_back(ofColor(202,246,70,a) );
colorTables.push_back(ofColor(74,236,173,a) );
colorTables.push_back(ofColor(253,144,150,a) );
colorTables.push_back(ofColor(41,176,238,a) );
colorTables.push_back(ofColor(180,155,45,a) );
colorTables.push_back(ofColor(63,216,92,a) );
colorTables.push_back(ofColor(226,246,139,a) );
colorTables.push_back(ofColor(239,209,46,a) );
colorTables.push_back(ofColor(234,127,169,a) );
colorTables.push_back(ofColor(227,184,233,a) );
colorTables.push_back(ofColor(165,154,206,a) );
#endif
}
ofxRemoteUIServer::~ofxRemoteUIServer(){
RUI_LOG_VERBOSE << "~ofxRemoteUIServer()" ;
}
void ofxRemoteUIServer::setSaveToXMLOnExit(bool save){
saveToXmlOnExit = save;
}
void ofxRemoteUIServer::setCallback( void (*callb)(RemoteUIServerCallBackArg) ){
callBack = callb;
}
void ofxRemoteUIServer::close(){
if(readyToSend)
sendCIAO();
if(threadedUpdate){
#ifdef OF_AVAILABLE
stopThread();
RUI_LOG_NOTICE << "ofxRemoteUIServer closing; waiting for update thread to end..." ;
waitForThread();
#endif
}
}
void ofxRemoteUIServer::setParamGroup(string g){
upcomingGroup = g;
newColorInGroupCounter = 1;
setNewParamColor(1);
setNewParamColorVariation(true);
addSpacer(g);
}
void ofxRemoteUIServer::unsetParamColor(){
colorSet = false;
}
void ofxRemoteUIServer::setNewParamColorVariation(bool dontChangeVariation){
paramColorCurrentVariation = paramColor;
if(!dontChangeVariation){
newColorInGroupCounter++;
}
int offset = newColorInGroupCounter%2;
paramColorCurrentVariation.a = BG_COLOR_ALPHA + offset * BG_COLOR_ALPHA * 0.75;
}
void ofxRemoteUIServer::setNewParamColor(int num){
for(int i = 0; i < num; i++){
ofColor c = colorTables[colorTableIndex];
colorSet = true;
paramColor = c;
colorTableIndex++;
if(colorTableIndex>= colorTables.size()){
colorTableIndex = 0;
}
}
}
void ofxRemoteUIServer::removeParamFromDB(string paramName){
unordered_map<string, RemoteUIParam>::iterator it = params.find(paramName);
if (it != params.end()){
params.erase(params.find(paramName));
it = paramsFromCode.find(paramName);
if (it != paramsFromCode.end()){
paramsFromCode.erase(paramsFromCode.find(paramName));
}
it = paramsFromXML.find(paramName);
if (it != paramsFromXML.end()){
paramsFromXML.erase(paramsFromXML.find(paramName));
}
//re-create orderedKeys
vector<string> myOrderedKeys;
unordered_map<int, string>::iterator iterator;
for(iterator = orderedKeys.begin(); iterator != orderedKeys.end(); iterator++) {
if (iterator->second != paramName){
//positionsToDelete.push_back(iterator->first);
myOrderedKeys.push_back(iterator->second);
}
}
orderedKeys.clear();
for(int i = 0; i < myOrderedKeys.size(); i++){
orderedKeys[i] = myOrderedKeys[i];
}
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer::removeParamFromDB >> trying to delete an unexistant param (" << paramName << ")" ;
}
}
void ofxRemoteUIServer::setDirectoryPrefix(string _directoryPrefix){
directoryPrefix = _directoryPrefix;
RUI_LOG_NOTICE << "ofxRemoteUIServer: directoryPrefix set to '" << directoryPrefix << "'";
#ifdef OF_AVAILABLE
ofDirectory d;
d.open(getFinalPath(OFXREMOTEUI_PRESET_DIR));
if(!d.exists()){
d.create(true);
}
#endif
}
void ofxRemoteUIServer::saveParamToXmlSettings(RemoteUIParam t, string key, ofxXmlSettings & s, XmlCounter & c){
switch (t.type) {
case REMOTEUI_PARAM_FLOAT:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.floatValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, (double)*t.floatValAddr, c.numFloats);
s.setAttribute(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numFloats);
c.numFloats++;
break;
case REMOTEUI_PARAM_INT:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.intValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_INT_PARAM_XML_TAG, (int)*t.intValAddr, c.numInts);
s.setAttribute(OFXREMOTEUI_INT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numInts);
c.numInts++;
break;
case REMOTEUI_PARAM_COLOR:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << (int)*t.redValAddr << " " << (int)*(t.redValAddr+1) << " " << (int)*(t.redValAddr+2) << " " << (int)*(t.redValAddr+3) << ") to XML" ;
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":R", (int)*t.redValAddr, c.numColors);
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":G", (int)*(t.redValAddr+1), c.numColors);
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":B", (int)*(t.redValAddr+2), c.numColors);
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":A", (int)*(t.redValAddr+3), c.numColors);
s.setAttribute(OFXREMOTEUI_COLOR_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numColors);
c.numColors++;
break;
case REMOTEUI_PARAM_ENUM:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.intValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_ENUM_PARAM_XML_TAG, (int)*t.intValAddr, c.numEnums);
s.setAttribute(OFXREMOTEUI_ENUM_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numEnums);
c.numEnums++;
break;
case REMOTEUI_PARAM_BOOL:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.boolValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_BOOL_PARAM_XML_TAG, (bool)*t.boolValAddr, c.numBools);
s.setAttribute(OFXREMOTEUI_BOOL_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numBools);
c.numBools++;
break;
case REMOTEUI_PARAM_STRING:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.stringValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_STRING_PARAM_XML_TAG, (string)*t.stringValAddr, c.numStrings);
s.setAttribute(OFXREMOTEUI_STRING_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numStrings);
c.numStrings++;
break;
case REMOTEUI_PARAM_SPACER:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer skipping save of spacer '" << key << "' to XML" ;
break;
default:
break;
}
}
void ofxRemoteUIServer::saveGroupToXML(string fileName, string groupName){
#ifdef OF_AVAILABLE
fileName = getFinalPath(fileName);
ofDirectory d;
string path = getFinalPath(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName);
d.open(path);
if(!d.exists()){
d.create(true);
}
#else
#if defined(_WIN32)
_mkdir(path.c_str());
#else
mkdir(fileName.c_str(), 0777);
#endif
#endif
RUI_LOG_NOTICE << "ofxRemoteUIServer: saving group to xml '" << fileName << "'" ;
ofxXmlSettings s;
s.loadFile(fileName);
s.clear();
s.addTag(OFXREMOTEUI_XML_TAG);
s.pushTag(OFXREMOTEUI_XML_TAG);
XmlCounter counters;
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
RemoteUIParam t = params[key];
if( t.group != OFXREMOTEUI_DEFAULT_PARAM_GROUP && t.group == groupName ){
saveParamToXmlSettings(t, key, s, counters);
}
}
s.saveFile(fileName);
}
void ofxRemoteUIServer::saveToXML(string fileName){
saveSettingsBackup(); //every time , before we save
#ifdef OF_AVAILABLE
fileName = getFinalPath(fileName);
#endif
RUI_LOG_NOTICE << "ofxRemoteUIServer: saving to xml '" << fileName << "'" ;
ofxXmlSettings s;
s.loadFile(fileName);
if(clearXmlOnSaving){
s.clear();
}
if (s.getNumTags(OFXREMOTEUI_XML_TAG) == 0){
s.addTag(OFXREMOTEUI_XML_TAG);
}
s.pushTag(OFXREMOTEUI_XML_TAG);
XmlCounter counters;
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
RemoteUIParam t = params[key];
saveParamToXmlSettings(t, key, s, counters);
}
s.popTag(); //pop OFXREMOTEUI_XML_TAG
if(!portIsSet){
s.setValue(OFXREMOTEUI_XML_PORT, port, 0);
}
s.saveFile(fileName);
}
vector<string> ofxRemoteUIServer::loadFromXML(string fileName){
#ifdef OF_AVAILABLE
fileName = getFinalPath(fileName);
#endif
vector<string> loadedParams;
ofxXmlSettings s;
bool exists = s.loadFile(fileName);
if (exists){
if( s.getNumTags(OFXREMOTEUI_XML_TAG) > 0 ){
s.pushTag(OFXREMOTEUI_XML_TAG, 0);
int numFloats = s.getNumTags(OFXREMOTEUI_FLOAT_PARAM_XML_TAG);
for (int i=0; i< numFloats; i++){
string paramName = s.getAttribute(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, 0.0, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].floatValAddr != NULL){
*params[paramName].floatValAddr = val;
params[paramName].floatVal = val;
*params[paramName].floatValAddr = ofClamp(*params[paramName].floatValAddr, params[paramName].minFloat, params[paramName].maxFloat);
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a FLOAT '" << paramName <<"' (" << ofToString( *params[paramName].floatValAddr, 3) << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading FLOAT (" << paramName << ")" ;
}
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer: float param '" <<paramName << "' defined in xml not found in DB!" ;
}
}
int numInts = s.getNumTags(OFXREMOTEUI_INT_PARAM_XML_TAG);
for (int i=0; i< numInts; i++){
string paramName = s.getAttribute(OFXREMOTEUI_INT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_INT_PARAM_XML_TAG, 0, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].intValAddr != NULL){
*params[paramName].intValAddr = val;
params[paramName].intVal = val;
*params[paramName].intValAddr = ofClamp(*params[paramName].intValAddr, params[paramName].minInt, params[paramName].maxInt);
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading an INT '" << paramName <<"' (" << (int) *params[paramName].intValAddr << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading INT (" << paramName << ")" ;
}
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer: int param '" <<paramName << "' defined in xml not found in DB!" ;
}
}
int numColors = s.getNumTags(OFXREMOTEUI_COLOR_PARAM_XML_TAG);
for (int i=0; i< numColors; i++){
string paramName = s.getAttribute(OFXREMOTEUI_COLOR_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, "OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY", i);
s.pushTag(OFXREMOTEUI_COLOR_PARAM_XML_TAG, i);
int r = s.getValue("R", 0);
int g = s.getValue("G", 0);
int b = s.getValue("B", 0);
int a = s.getValue("A", 0);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].redValAddr != NULL){
*params[paramName].redValAddr = r;
params[paramName].redVal = r;
*(params[paramName].redValAddr+1) = g;
params[paramName].greenVal = g;
*(params[paramName].redValAddr+2) = b;
params[paramName].blueVal = b;
*(params[paramName].redValAddr+3) = a;
params[paramName].alphaVal = a;
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a COLOR '" << paramName <<"' (" << (int)*params[paramName].redValAddr << " " << (int)*(params[paramName].redValAddr+1) << " " << (int)*(params[paramName].redValAddr+2) << " " << (int)*(params[paramName].redValAddr+3) << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading COLOR (" << paramName << ")" ;
}
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: color param '" <<paramName << "' defined in xml not found in DB!" ;
}
s.popTag();
}
int numEnums = s.getNumTags(OFXREMOTEUI_ENUM_PARAM_XML_TAG);
for (int i=0; i< numEnums; i++){
string paramName = s.getAttribute(OFXREMOTEUI_ENUM_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_ENUM_PARAM_XML_TAG, 0, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].intValAddr != NULL){
*params[paramName].intValAddr = val;
params[paramName].intVal = val;
*params[paramName].intValAddr = ofClamp(*params[paramName].intValAddr, params[paramName].minInt, params[paramName].maxInt);
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading an ENUM '" << paramName <<"' (" << (int) *params[paramName].intValAddr << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading ENUM (" << paramName << ")" ;
}
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: enum param '" << paramName << "' defined in xml not found in DB!" ;
}
}
int numBools = s.getNumTags(OFXREMOTEUI_BOOL_PARAM_XML_TAG);
for (int i=0; i< numBools; i++){
string paramName = s.getAttribute(OFXREMOTEUI_BOOL_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_BOOL_PARAM_XML_TAG, false, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].boolValAddr != NULL){
*params[paramName].boolValAddr = val;
params[paramName].boolVal = val;
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a BOOL '" << paramName <<"' (" << (bool) *params[paramName].boolValAddr << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading BOOL (" << paramName << ")" ;
}
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: bool param '" << paramName << "' defined in xml not found in DB!" ;
}
}
int numStrings = s.getNumTags(OFXREMOTEUI_STRING_PARAM_XML_TAG);
for (int i=0; i< numStrings; i++){
string paramName = s.getAttribute(OFXREMOTEUI_STRING_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
string val = s.getValue(OFXREMOTEUI_STRING_PARAM_XML_TAG, "", i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].stringValAddr != NULL){
params[paramName].stringVal = val;
*params[paramName].stringValAddr = val;
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a STRING '" << paramName <<"' (" << (string) *params[paramName].stringValAddr << ") from XML" ;
}
else RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading STRING (" << paramName << ")" ;
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: string param '" << paramName << "' defined in xml not found in DB!" ;
}
}
}
}
vector<string> paramsNotInXML;
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string paramName = (*ii).first;
//param name found in xml
if( find(loadedParams.begin(), loadedParams.end(), paramName) != loadedParams.end() ){
}else{ //param name not in xml
if ((*ii).second.type != REMOTEUI_PARAM_SPACER){ //spacers dont count as params really
paramsNotInXML.push_back(paramName);
}
}
}
loadedFromXML = true;
return paramsNotInXML;
}
void ofxRemoteUIServer::restoreAllParamsToInitialXML(){
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
if (params[key].type != REMOTEUI_PARAM_SPACER){
params[key] = paramsFromXML[key];
syncPointerToParam(key);
}
}
}
void ofxRemoteUIServer::restoreAllParamsToDefaultValues(){
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
params[key] = paramsFromCode[key];
syncPointerToParam(key);
}
}
void ofxRemoteUIServer::pushParamsToClient(){
if(readyToSend){
vector<string>changedParams = scanForUpdatedParamsAndSync();
vector<string>paramsList = getAllParamNamesList();
syncAllParamsToPointers();
sendUpdateForParamsInList(paramsList);
#ifdef OF_AVAILABLE
for(int i = 0 ; i < changedParams.size(); i++){
string pName = changedParams[i];
RemoteUIParam p = params[pName];
onScreenNotifications.addParamUpdate(pName, p.getValueAsString(),
p.type == REMOTEUI_PARAM_COLOR ?
ofColor(p.redVal, p.greenVal, p.blueVal, p.alphaVal) :
ofColor(0,0,0,0)
);
}
#endif
sendREQU(true); //once all send, confirm to close the REQU
}
}
void ofxRemoteUIServer::setNetworkInterface(string iface){
userSuppliedNetInterface = iface;
}
string ofxRemoteUIServer::getFinalPath(string p){
if(directoryPrefix.size()){
stringstream ss;
ss << directoryPrefix << "/" << p;
p = ss.str();
}
return p;
}
void ofxRemoteUIServer::saveSettingsBackup(){
#ifdef OF_AVAILABLE
if(autoBackups){
ofDirectory d;
d.open( getFinalPath(OFXREMOTEUI_SETTINGS_BACKUP_FOLDER) );
if (!d.exists()){
ofDirectory::createDirectory(getFinalPath(OFXREMOTEUI_SETTINGS_BACKUP_FOLDER));
}d.close();
string basePath = OFXREMOTEUI_SETTINGS_BACKUP_FOLDER + string("/") + ofFilePath::removeExt(OFXREMOTEUI_SETTINGS_FILENAME) + ".";
basePath = getFinalPath(basePath);
for (int i = OFXREMOTEUI_NUM_BACKUPS - 1; i >= 0; i--){
string originalPath = basePath + ofToString(i) + ".xml";
string destPath = basePath + ofToString(i+1) + ".xml";
ofFile og;
og.open(originalPath);
if ( og.exists() ){
try{
ofFile::moveFromTo(originalPath, destPath, true, true); //TODO complains on windows!
}catch(...){}
}
og.close();
}
ofFile f;
f.open(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME));
if(f.exists()){
try{
ofFile::copyFromTo(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME), basePath + "0.xml");
}catch(...){}
}
f.close();
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer saving a backup of the current " << getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME) << " in " << getFinalPath(OFXREMOTEUI_SETTINGS_BACKUP_FOLDER) ;
}
#endif
}
void ofxRemoteUIServer::setup(int port_, float updateInterval_){
#ifdef OF_AVAILABLE
ofDirectory d;
d.open(getFinalPath(OFXREMOTEUI_PRESET_DIR));
if(!d.exists()){
d.create(true);
}
#else
#if defined(_WIN32)
_mkdir(getFinalPath(OFXREMOTEUI_PRESET_DIR));
#else
mkdir(getFinalPath(OFXREMOTEUI_PRESET_DIR).c_str(), (mode_t)0777);
#endif
#endif
//check for enabled
string configFile;
#ifdef OF_AVAILABLE
ofxXmlSettings s;
configFile = ofToDataPath(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME));
bool exists = s.loadFile(configFile);
if(exists){
if( s.getNumTags(OFXREMOTEUI_XML_ENABLED) > 0 ){
enabled = ("true" == s.getValue(OFXREMOTEUI_XML_ENABLED, "true"));
if (!enabled){
RUI_LOG_WARNING << "ofxRemoteUIServer launching disabled!" ;
}
}
}
#else
configFile = getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME);
enabled = true;
#endif
if(enabled){
//setup the broadcasting
computerIP = getMyIP(userSuppliedNetInterface);
doBroadcast = true;
string multicastIP;
if (computerIP != RUI_LOCAL_IP_ADDRESS){
vector<string>comps;
split(comps, computerIP, '.');
multicastIP = comps[0] + "." + comps[1] + "." + comps[2] + "." + "255";
}else{
multicastIP = "255.255.255.255";
}
broadcastSender.setup( multicastIP, OFXREMOTEUI_BROADCAST_PORT ); //multicast @
RUI_LOG_NOTICE << "ofxRemoteUIServer: letting everyone know that I am at " << multicastIP << ":" << OFXREMOTEUI_BROADCAST_PORT ;
if(port_ == -1){ //if no port specified, pick a random one, but only the very first time we get launched!
portIsSet = false;
ofxXmlSettings s;
bool exists = s.loadFile(configFile);
bool portNeedsToBePicked = false;
if (exists){
if( s.getNumTags(OFXREMOTEUI_XML_PORT) > 0 ){
port_ = s.getValue(OFXREMOTEUI_XML_PORT, 10000);
}else{
portNeedsToBePicked = true;
}
}else{
portNeedsToBePicked = true;
}
if(portNeedsToBePicked){
#ifdef OF_AVAILABLE
ofSeedRandom();
port_ = ofRandom(5000, 60000);
#else
srand (time(NULL));
port_ = 5000 + rand()%55000;
#endif
ofxXmlSettings s2;
s2.loadFile(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME));
s2.setValue(OFXREMOTEUI_XML_PORT, port_, 0);
s2.saveFile();
}
}else{
portIsSet = true;
}
params.clear();
updateInterval = updateInterval_;
waitingForReply = false;
avgTimeSinceLastReply = timeSinceLastReply = timeCounter = 0.0f;
port = port_;
RUI_LOG_NOTICE << "ofxRemoteUIServer listening at port " << port << " ... " ;
oscReceiver.setup(port);
}
//still get ui access despite being disabled
#ifdef OF_AVAILABLE
ofAddListener(ofEvents().exit, this, &ofxRemoteUIServer::_appExited); //to save to xml, disconnect, etc
ofAddListener(ofEvents().keyPressed, this, &ofxRemoteUIServer::_keyPressed);
ofAddListener(ofEvents().update, this, &ofxRemoteUIServer::_update);
ofAddListener(ofEvents().draw, this, &ofxRemoteUIServer::_draw);
#endif
}
#ifdef OF_AVAILABLE
void ofxRemoteUIServer::_appExited(ofEventArgs &e){
if(!enabled) return;
OFX_REMOTEUI_SERVER_CLOSE(); //stop the server
if(saveToXmlOnExit){
OFX_REMOTEUI_SERVER_SAVE_TO_XML(); //save values to XML
}
}
void ofxRemoteUIServer::_keyPressed(ofKeyEventArgs &e){
if (showUI){
switch(e.key){ //you can save current config from tab screen by pressing s
case 's':
saveToXML(OFXREMOTEUI_SETTINGS_FILENAME);
onScreenNotifications.addNotification("SAVED CONFIG to default XML");
break;
case 'S':{
bool groupIsSelected = false;
string groupName;
if (selectedItem >= 0){ //selection on params list
string key = orderedKeys[selectedItem];
RemoteUIParam p = params[key];
if (p.type == REMOTEUI_PARAM_SPACER){
groupIsSelected = true;
groupName = p.group;
}
}
string presetName = ofSystemTextBoxDialog(groupIsSelected ?
"Create a New Group Preset For " + groupName
:
"Create a New Global Preset" ,
"");
if(presetName.size()){
RemoteUIServerCallBackArg cbArg;
if (groupIsSelected){
saveGroupToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName + "/" + presetName + ".xml", groupName);
if(callBack) callBack(cbArg);
cbArg.action = CLIENT_SAVED_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
#ifdef OF_AVAILABLE
ofNotifyEvent(clientAction, cbArg, this);
onScreenNotifications.addNotification("SAVED PRESET '" + presetName + ".xml' FOR GROUP '" + groupName + "'");
#endif
}else{
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: saving NEW preset: " << presetName ;
saveToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
cbArg.action = CLIENT_SAVED_PRESET;
cbArg.msg = presetName;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack) callBack(cbArg);
}
refreshPresetsCache();
}
}break;
case 'r':
restoreAllParamsToInitialXML();
onScreenNotifications.addNotification("RESET CONFIG TO SERVER-LAUNCH XML values");
break;
case OF_KEY_RETURN:
if(selectedItem == -1 && selectedPreset >= 0){ //global presets
lastChosenPreset = presetsCached[selectedPreset];
loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + lastChosenPreset + ".xml");
syncAllPointersToParams();
uiAlpha = 0;
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset: " << lastChosenPreset ;
RemoteUIServerCallBackArg cbArg;
cbArg.action = CLIENT_DID_SET_PRESET;
cbArg.msg = lastChosenPreset;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SET PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + lastChosenPreset + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
}
if (selectedItem >= 0){ //selection on params list
string key = orderedKeys[selectedItem];
RemoteUIParam p = params[key];
if(p.type == REMOTEUI_PARAM_SPACER && groupPresetsCached[p.group].size() > 0){
string presetName = p.group + "/" + groupPresetsCached[p.group][selectedGroupPreset];
loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
syncAllPointersToParams();
uiAlpha = 0;
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset: " << presetName ;
RemoteUIServerCallBackArg cbArg;
cbArg.action = CLIENT_DID_SET_GROUP_PRESET;
cbArg.msg = p.group;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
ofNotifyEvent(clientAction, cbArg, this);
onScreenNotifications.addNotification("SET '" + p.group + "' GROUP TO '" + presetName + ".xml' PRESET");
#endif
}
}
break;
case OF_KEY_DOWN:
case OF_KEY_UP:{
float sign = e.key == OF_KEY_DOWN ? 1.0 : -1.0;
selectedGroupPreset = 0;
uiAlpha = 1;
selectedItem += sign;
if(selectedItem < -1) selectedItem = orderedKeys.size() - 1;
if(selectedItem >= orderedKeys.size()) selectedItem = -1; //presets menu >> selectedItem = -1, on top of all
selectedGroupPreset = 0;
}break;
case OF_KEY_LEFT:
case OF_KEY_RIGHT:{
float sign = e.key == OF_KEY_RIGHT ? 1.0 : -1.0;
if (selectedItem >= 0){ //params
string key = orderedKeys[selectedItem];
RemoteUIParam p = params[key];
if (p.type != REMOTEUI_PARAM_SPACER){
uiAlpha = 0;
switch (p.type) {
case REMOTEUI_PARAM_FLOAT:
p.floatVal += sign * (p.maxFloat - p.minFloat) * 0.0025;
p.floatVal = ofClamp(p.floatVal, p.minFloat, p.maxFloat);
break;
case REMOTEUI_PARAM_ENUM:
case REMOTEUI_PARAM_INT:
p.intVal += sign;
p.intVal = ofClamp(p.intVal, p.minInt, p.maxInt);
break;
case REMOTEUI_PARAM_BOOL:
p.boolVal = !p.boolVal;
break;
default:
break;
}
params[key] = p;
syncPointerToParam(key);
pushParamsToClient();
RemoteUIServerCallBackArg cbArg;
cbArg.action = CLIENT_DID_RESET_TO_XML;
cbArg.host = "localhost";
cbArg.action = CLIENT_UPDATED_PARAM;
cbArg.paramName = key;
cbArg.param = params[key]; //copy the updated param to the callbakc arg
#ifdef OF_AVAILABLE
onScreenNotifications.addParamUpdate(key, cbArg.param.getValueAsString());
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack) callBack(cbArg);
}else{ //in spacer! group time, cycle through group presets
int numGroupPresets = groupPresetsCached[p.group].size();
if(numGroupPresets > 0){
selectedGroupPreset += sign;
if (selectedGroupPreset < 0) selectedGroupPreset = numGroupPresets -1;
if (selectedGroupPreset > numGroupPresets -1) selectedGroupPreset = 0;
}
}
}else{ //presets!
if (presetsCached.size()){
selectedPreset += sign;
int limit = presetsCached.size() - 1;
if (selectedPreset > limit){
selectedPreset = 0;
}
if (selectedPreset < 0){
selectedPreset = limit;
}
}
}
}break;
}
}
if(e.key == showInterfaceKey){
if (uiAlpha < 1.0 && showUI){
uiAlpha = 1.0;
showUI = false;
}else{
showUI = !showUI;
}
if (showUI){
uiAlpha = 1;
uiLines.clear();
syncAllPointersToParams();
refreshPresetsCache();
}
}
}
void ofxRemoteUIServer::refreshPresetsCache(){
//get all group presets
groupPresetsCached.clear();
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
if((*ii).second.type == REMOTEUI_PARAM_SPACER){
groupPresetsCached[(*ii).second.group] = getAvailablePresetsForGroup((*ii).second.group);
};
}
presetsCached = getAvailablePresets(true);
if (selectedPreset > presetsCached.size() -1){
selectedPreset = 0;
}
}
void ofxRemoteUIServer::startInBackgroundThread(){
threadedUpdate = true;
startThread();
}
#endif
void ofxRemoteUIServer::update(float dt){
#ifdef OF_AVAILABLE
if(!threadedUpdate){
updateServer(dt);
}
uiAlpha += 0.3 * ofGetLastFrameTime();
if(uiAlpha > 1) uiAlpha = 1;
#else
updateServer(dt);
#endif
}
#ifdef OF_AVAILABLE
void ofxRemoteUIServer::threadedFunction(){
while (isThreadRunning()) {
updateServer(1./30.); //30 fps timebase
ofSleepMillis(33);
}
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer threadedFunction() ending" ;
}
void ofxRemoteUIServer::_draw(ofEventArgs &e){
ofSetupScreen(); //mmm this is a bit scary //TODO!
draw( 20, ofGetHeight() - 20);
}
void ofxRemoteUIServer::_update(ofEventArgs &e){
update(ofGetLastFrameTime());
}
void ofxRemoteUIServer::draw(int x, int y){
ofPushStyle();
ofFill();
ofEnableAlphaBlending();
if(showUI){
int padding = 30;
int x = padding;
int initialY = padding * 1.5;
int y = initialY;
int colw = uiColumnWidth;
int realColW = colw * 0.9;
int valOffset = realColW * 0.7;
int valSpaceW = realColW - valOffset;
int spacing = 20;
int bottomBarHeight = padding + spacing + 36;
//bottom bar
if (uiAlpha > 0.99){
ofSetColor(11, 245 * uiAlpha);
ofRect(0,0, ofGetWidth(), ofGetHeight());
ofSetColor(44, 245);
ofRect(0,ofGetHeight() - bottomBarHeight, ofGetWidth(), bottomBarHeight );
ofSetColor(255);
ofDrawBitmapString("ofxRemoteUI built in client. " +
string(enabled ? ("Server reachable at " + computerIP + ":" + ofToString(port)) + "." :
"Sever Disabled." ) +
"\nPress 's' to save current config.\n" +
"Press 'S' to make a new preset.\n" +
"Press 'r' to restore all param's launch state.\n" +
"Use Arrow Keys to edit values. Press 'TAB' to hide.", padding, ofGetHeight() - bottomBarHeight + 20);
}
//preset selection / top bar
ofSetColor(64);
ofRect(0 , 0, ofGetWidth(), 22);
ofColor textBlinkC ;
if(ofGetFrameNum()%5 < 1) textBlinkC = ofColor(255);
else textBlinkC = ofColor(255,0,0);
if(presetsCached.size() > 0 && selectedPreset >= 0 && selectedPreset < presetsCached.size()){
ofVec2f dpos = ofVec2f(192, 16);
ofSetColor(180);
if (selectedItem < 0){
ofDrawBitmapString("Press RETURN to load GLOBAL PRESET: \"" + presetsCached[selectedPreset] + "\"", dpos);
ofSetColor(textBlinkC);
ofDrawBitmapString(" " + presetsCached[selectedPreset], dpos);
}else{
RemoteUIParam p = params[orderedKeys[selectedItem]];
int howMany = 0;
if(p.type == REMOTEUI_PARAM_SPACER){
howMany = groupPresetsCached[p.group].size();
if (howMany > 0){
string msg = "Press RETURN to load \"" + p.group + "\" GROUP PRESET: \"";
ofDrawBitmapString( msg + groupPresetsCached[p.group][selectedGroupPreset] + "\"", dpos);
ofSetColor(textBlinkC);
ofDrawBitmapString(groupPresetsCached[p.group][selectedGroupPreset],
dpos + ofVec2f(msg.length() * 8, 0));
}
}
if(howMany == 0){
ofSetColor(180);
ofDrawBitmapString("Selected Preset: NONE", dpos);
}
}
}
if (selectedItem != -1) ofSetColor(255);
else ofSetColor(textBlinkC);
ofDrawBitmapString("+ PRESET SELECTION: " , 30, 16);
int linesInited = uiLines.getNumVertices() > 0 ;
if(uiAlpha > 0.99){
//param list
for(int i = 0; i < orderedKeys.size(); i++){
string key = orderedKeys[i];
RemoteUIParam p = params[key];
int chars = key.size();
int charw = 9;
int column2MaxLen = ceil(valSpaceW / charw) + 1;
int stringw = chars * charw;
if (stringw > valOffset){
key = key.substr(0, (valOffset) / charw );
}
if (selectedItem != i){
ofSetColor(p.r, p.g, p.b);
}else{
if(ofGetFrameNum()%5 < 1) ofSetColor(222);
else ofSetColor(255,0,0);
}
if(p.type != REMOTEUI_PARAM_SPACER){
string sel = (selectedItem == i) ? ">>" : " ";
ofDrawBitmapString(sel + key, x, y);
}else{
ofPushStyle();
ofColor c = ofColor(p.r, p.g, p.b);
ofSetColor(c * 0.3);
ofRect(x , -spacing + y + spacing * 0.33, realColW, spacing);
ofPopStyle();
ofDrawBitmapString("+ " + p.stringVal, x,y);
}
switch (p.type) {
case REMOTEUI_PARAM_FLOAT:
ofDrawBitmapString(ofToString(p.floatVal), x + valOffset, y);
break;
case REMOTEUI_PARAM_ENUM:
if (p.intVal >= 0 && p.intVal < p.enumList.size() && p.enumList.size() > 0){
string val = p.enumList[p.intVal];
if (val.length() > column2MaxLen){
val = val.substr(0, column2MaxLen);
}
ofDrawBitmapString(val, x + valOffset, y);
}else{
ofDrawBitmapString(ofToString(p.intVal), x + valOffset, y);
}
break;
case REMOTEUI_PARAM_INT:
ofDrawBitmapString(ofToString(p.intVal), x + valOffset, y);
break;
case REMOTEUI_PARAM_BOOL:
ofDrawBitmapString(p.boolVal ? "true" : "false", x + valOffset, y);
break;
case REMOTEUI_PARAM_STRING:
ofDrawBitmapString(p.stringVal, x + valOffset, y);
break;
case REMOTEUI_PARAM_COLOR:
ofSetColor(p.redVal, p.greenVal, p.blueVal, p.alphaVal);
ofRect(x + valOffset, y - spacing * 0.6, 64, spacing * 0.85);
break;
case REMOTEUI_PARAM_SPACER:{
int howMany = groupPresetsCached[p.group].size();
if (selectedItem == i){ //selected
if (selectedGroupPreset < howMany && selectedGroupPreset >= 0){
string presetName = groupPresetsCached[p.group][selectedGroupPreset];
if (presetName.length() > column2MaxLen){
presetName = presetName.substr(0, column2MaxLen);
}
ofDrawBitmapString(presetName, x + valOffset, y);
}
}else{ //not selected
if(howMany > 0 ){
ofDrawBitmapString("(" + ofToString(howMany) + ")", x + valOffset, y);
}
}
}break;
default: printf("weird RemoteUIParam at draw()!\n"); break;
}
if(!linesInited){
uiLines.addVertex(ofVec2f(x, y + spacing * 0.33));
uiLines.addVertex(ofVec2f(x + realColW, y + spacing * 0.33));
}
y += spacing;
if (y > ofGetHeight() - padding * 0.5 - bottomBarHeight){
x += colw;
y = initialY;
}
}
ofSetColor(32);
ofSetLineWidth(1);
uiLines.draw();
}
//tiny clock top left
if (uiAlpha < 1.0){
ofMesh m;
int step = 30;
m.setMode(OF_PRIMITIVE_TRIANGLE_FAN);
ofVec2f origin = ofVec2f(15,11); //rect is 22
m.addVertex(origin);
float r = 8.0f;
float ang;
float lim = 360.0f * (1.0f - uiAlpha);
for(ang = 0; ang < lim; ang += step){
m.addVertex( origin + ofVec2f( r * cosf((-90.0f + ang) * DEG_TO_RAD),
r * sinf((-90.0f + ang) * DEG_TO_RAD)));
}
float lastBit = lim - ang;
m.addVertex( origin + ofVec2f( r * cosf((-90.0f + ang + lastBit) * DEG_TO_RAD),
r * sinf((-90.0f + ang + lastBit) * DEG_TO_RAD)));
ofSetColor(128);
m.draw();
}
}
if (!showUI || uiAlpha < 1.0){
if (drawNotifications){
for(int i = 0; i < paramsToWatch.size(); i++){
onScreenNotifications.addParamWatch(paramsToWatch[i], params[paramsToWatch[i]].getValueAsStringFromPointer());
}
onScreenNotifications.draw(x, y);
}
}
ofPopStyle();
}
#endif
void ofxRemoteUIServer::handleBroadcast(){
if(doBroadcast){
if(broadcastTime > OFXREMOTEUI_BORADCAST_INTERVAL){
broadcastTime = 0.0f;
if (computerName.size() == 0){
#ifdef OF_AVAILABLE
Poco::Environment e;
computerName = e.nodeName();
char pathbuf[2048];
uint32_t bufsize = sizeof(pathbuf);
#ifdef TARGET_OSX
_NSGetExecutablePath(pathbuf, &bufsize);
Poco::Path p = Poco::Path(pathbuf);
binaryName = p[p.depth()];
#else
#ifdef TARGET_WIN32
GetModuleFileNameA( NULL, pathbuf, bufsize ); //no idea why, but GetModuleFileName() is not defined?
Poco::Path p = Poco::Path(pathbuf);
binaryName = p[p.depth()];
#else
char procname[1024];
int len = readlink("/proc/self/exe", procname, 1024-1);
if (len > 0){
procname[len] = '\0';
Poco::Path p = Poco::Path(procname);
binaryName = p[p.depth()];
}
#endif
#endif
#endif
}
ofxOscMessage m;
m.addIntArg(port); //0
m.addStringArg(computerName); //1
m.addStringArg(binaryName); //2
m.addIntArg(broadcastCount); // 3
broadcastSender.sendMessage(m);
broadcastCount++;
}
}
}
void ofxRemoteUIServer::updateServer(float dt){
#ifdef OF_AVAILABLE
onScreenNotifications.update(dt);
#endif
if(!enabled) return;
timeCounter += dt;
broadcastTime += dt;
timeSinceLastReply += dt;
if(readyToSend){
if (timeCounter > updateInterval){
timeCounter = 0.0f;
//vector<string> changes = scanForUpdatedParamsAndSync(); //sends changed params to client
//cout << "ofxRemoteUIServer: sent " << ofToString(changes.size()) << " updates to client" ;
//sendUpdateForParamsInList(changes);
}
}
//let everyone know I exist and which is my port, every now and then
handleBroadcast();
while( oscReceiver.hasWaitingMessages() ){// check for waiting messages from client
ofxOscMessage m;
oscReceiver.getNextMessage(&m);
if (!readyToSend){ // if not connected, connect to our friend so we can talk back
connect(m.getRemoteIp(), port + 1);
}
DecodedMessage dm = decode(m);
RemoteUIServerCallBackArg cbArg; // to notify our "delegate"
cbArg.host = m.getRemoteIp();
switch (dm.action) {
case HELO_ACTION: //if client says hi, say hi back
sendHELLO();
cbArg.action = CLIENT_CONNECTED;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("CONNECTED (" + cbArg.host + ")!");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " says HELLO!" ;
break;
case REQUEST_ACTION:{ //send all params to client
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " sends REQU!" ;
pushParamsToClient();
}break;
case SEND_PARAM_ACTION:{ //client is sending us an updated val
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " sends SEND!" ;
updateParamFromDecodedMessage(m, dm);
cbArg.action = CLIENT_UPDATED_PARAM;
cbArg.paramName = dm.paramName;
cbArg.param = params[dm.paramName]; //copy the updated param to the callbakc arg
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
RemoteUIParam p = params[dm.paramName];
onScreenNotifications.addParamUpdate(dm.paramName, p.getValueAsString(),
p.type == REMOTEUI_PARAM_COLOR ?
ofColor(p.redVal, p.greenVal, p.blueVal, p.alphaVal):
ofColor(0,0,0,0)
);
ofNotifyEvent(clientAction, cbArg, this);
#endif
}
break;
case CIAO_ACTION:{
sendCIAO();
cbArg.action = CLIENT_DISCONNECTED;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("DISCONNECTED (" + cbArg.host + ")!");
ofNotifyEvent(clientAction, cbArg, this);
#endif
clearOscReceiverMsgQueue();
readyToSend = false;
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " says CIAO!" ;
}break;
case TEST_ACTION: // we got a request from client, lets bounce back asap.
sendTEST();
//if(verbose)RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " says TEST!" ;
break;
case PRESET_LIST_ACTION: //client wants us to send a list of all available presets
presetNames = getAvailablePresets();
if (presetNames.size() == 0){
presetNames.push_back(OFXREMOTEUI_NO_PRESETS);
}
sendPREL(presetNames);
break;
case SET_PRESET_ACTION:{ // client wants to set a preset
string presetName = m.getArgAsString(0);
vector<string> missingParams = loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
sendSETP(presetName);
sendMISP(missingParams);
cbArg.action = CLIENT_DID_SET_PRESET;
cbArg.msg = presetName;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SET PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset: " << presetName ;
}break;
case SAVE_PRESET_ACTION:{ //client wants to save current xml as a new preset
string presetName = m.getArgAsString(0);
saveToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
sendSAVP(presetName);
cbArg.action = CLIENT_SAVED_PRESET;
cbArg.msg = presetName;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: saving NEW preset: " << presetName ;
}break;
case DELETE_PRESET_ACTION:{
string presetName = m.getArgAsString(0);
deletePreset(presetName);
sendDELP(presetName);
cbArg.action = CLIENT_DELETED_PRESET;
cbArg.msg = presetName;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("DELETED PRESET '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: DELETE preset: " << presetName ;
#endif
}break;
case SAVE_CURRENT_STATE_ACTION:{
saveToXML(OFXREMOTEUI_SETTINGS_FILENAME);
cbArg.action = CLIENT_SAVED_STATE;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED CONFIG to default XML");
ofNotifyEvent(clientAction, cbArg, this);
#endif
sendSAVE(true);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: SAVE CURRENT PARAMS TO DEFAULT XML: " ;
}break;
case RESET_TO_XML_ACTION:{
restoreAllParamsToInitialXML();
sendRESX(true);
cbArg.action = CLIENT_DID_RESET_TO_XML;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("RESET CONFIG TO SERVER-LAUNCH XML values");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack)callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: RESET TO XML: " ;
}break;
case RESET_TO_DEFAULTS_ACTION:{
cbArg.action = CLIENT_DID_RESET_TO_DEFAULTS;
restoreAllParamsToDefaultValues();
sendRESD(true);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("RESET CONFIG TO DEFAULTS (source defined values)");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack)callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: RESET TO DEFAULTS: " ;
}break;
case SET_GROUP_PRESET_ACTION:{ // client wants to set a preset for a group
string presetName = m.getArgAsString(0);
string groupName = m.getArgAsString(1);
vector<string> missingParams = loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName + "/" + presetName + ".xml");
vector<string> filtered;
for(int i = 0; i < missingParams.size(); i++){
if ( params[ missingParams[i] ].group == groupName ){
filtered.push_back(missingParams[i]);
}
}
sendSETp(presetName, groupName);
sendMISP(filtered);
cbArg.action = CLIENT_DID_SET_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
if(callBack)callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SET '" + groupName + "' GROUP TO '" + presetName + ".xml' PRESET");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset group: " << groupName << "/" <<presetName ;
}break;
case SAVE_GROUP_PRESET_ACTION:{ //client wants to save current xml as a new preset
string presetName = m.getArgAsString(0);
string groupName = m.getArgAsString(1);
saveGroupToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName + "/" + presetName + ".xml", groupName);
sendSAVp(presetName, groupName);
cbArg.action = CLIENT_SAVED_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED PRESET '" + presetName + ".xml' FOR GROUP '" + groupName + "'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack) callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: saving NEW preset: " << presetName ;
}break;
case DELETE_GROUP_PRESET_ACTION:{
string presetName = m.getArgAsString(0);
string groupName = m.getArgAsString(1);
deletePreset(presetName, groupName);
sendDELp(presetName, groupName);
cbArg.action = CLIENT_DELETED_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("DELETED PRESET '" + presetName + ".xml' FOR GROUP'" + groupName + "'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack)callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: DELETE preset: " << presetName ;
}break;
default: RUI_LOG_ERROR << "ofxRemoteUIServer::update >> ERR!"; break;
}
}
}
void ofxRemoteUIServer::deletePreset(string name, string group){
#ifdef OF_AVAILABLE
ofDirectory dir;
if (group == "")
dir.open(getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + name + ".xml");
else
dir.open(getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + group + "/" + name + ".xml");
dir.remove(true);
#else
string file = getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + name + ".xml";
if (group != "") file = getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + group + "/" + name + ".xml";
remove( file.c_str() );
#endif
}
vector<string> ofxRemoteUIServer::getAvailablePresets(bool onlyGlobal){
vector<string> presets;
#ifdef OF_AVAILABLE
ofDirectory dir;
dir.listDir(ofToDataPath(getFinalPath(OFXREMOTEUI_PRESET_DIR)));
vector<ofFile> files = dir.getFiles();
for(int i = 0; i < files.size(); i++){
string fileName = files[i].getFileName();
string extension = files[i].getExtension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (files[i].isFile() && extension == "xml"){
string presetName = fileName.substr(0, fileName.size()-4);
presets.push_back(presetName);
}
if (files[i].isDirectory() && !onlyGlobal){
ofDirectory dir2;
dir2.listDir( ofToDataPath( getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + fileName) );
vector<ofFile> files2 = dir2.getFiles();
for(int j = 0; j < files2.size(); j++){
string fileName2 = files2[j].getFileName();
string extension2 = files2[j].getExtension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (files2[j].isFile() && extension2 == "xml"){
string presetName2 = fileName2.substr(0, fileName2.size()-4);
presets.push_back(fileName + "/" + presetName2);
}
}
}
}
#else
DIR *dir2;
struct dirent *ent;
if ((dir2 = opendir(getFinalPath(OFXREMOTEUI_PRESET_DIR).c_str() )) != NULL) {
while ((ent = readdir (dir2)) != NULL) {
if ( strcmp( get_filename_ext(ent->d_name), "xml") == 0 ){
string fileName = string(ent->d_name);
string presetName = fileName.substr(0, fileName.size()-4);
presets.push_back(presetName);
}
}
closedir(dir2);
}
#endif
return presets;
}
vector<string> ofxRemoteUIServer::getAvailablePresetsForGroup(string group){
vector<string> presets;
#ifdef OF_AVAILABLE
ofDirectory dir;
string path = ofToDataPath(getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + group );
if(ofDirectory::doesDirectoryExist(path)){
dir.listDir(path);
vector<ofFile> files = dir.getFiles();
for(int i = 0; i < files.size(); i++){
string fileName = files[i].getFileName();
string extension = files[i].getExtension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (files[i].isFile() && extension == "xml"){
string presetName = fileName.substr(0, fileName.size()-4);
presets.push_back(presetName);
}
}
}
#endif
return presets;
}
void ofxRemoteUIServer::setColorForParam(RemoteUIParam &p, ofColor c){
if (c.a > 0){ //if user supplied a color, override the setColor
p.r = c.r; p.g = c.g; p.b = c.b; p.a = c.a;
}else{
if (colorSet){
p.r = paramColorCurrentVariation.r;
p.g = paramColorCurrentVariation.g;
p.b = paramColorCurrentVariation.b;
p.a = paramColorCurrentVariation.a;
}
}
}
void ofxRemoteUIServer::watchParamOnScreen(string paramName){
if (params.find(paramName) != params.end()){
paramsToWatch.push_back(paramName);
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer can't watch that param; it doesnt exist! " << paramName << endl;
}
}
void ofxRemoteUIServer::addSpacer(string title){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_SPACER;
p.stringVal = title;
p.r = paramColor.r;
p.g = paramColor.g;
p.b = paramColor.b;
p.group = upcomingGroup; //to ignore those in the client app later when grouping
p.a = 255; //spacer has full alpha
#ifdef OF_AVAILABLE
addParamToDB(p, title + " - " + ofToString((int)ofRandom(1000000)));
#else
addParamToDB(p, title + " - " + ofToString(rand()%1000000));
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Adding Group '" << title << "' #######################" ;
}
void ofxRemoteUIServer::shareParam(string paramName, float* param, float min, float max, ofColor c){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_FLOAT;
p.floatValAddr = param;
p.maxFloat = max;
p.minFloat = min;
p.floatVal = *param = ofClamp(*param, min, max);
p.group = upcomingGroup;
setColorForParam(p, c);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Float Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, bool* param, ofColor c, int nothingUseful ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_BOOL;
p.boolValAddr = param;
p.boolVal = *param;
p.group = upcomingGroup;
setColorForParam(p, c);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Bool Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, int* param, int min, int max, ofColor c ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_INT;
p.intValAddr = param;
p.maxInt = max;
p.minInt = min;
p.group = upcomingGroup;
setColorForParam(p, c);
p.intVal = *param = ofClamp(*param, min, max);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Int Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, int* param, int min, int max, vector<string> names, ofColor c ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_ENUM;
p.intValAddr = param;
p.maxInt = max;
p.minInt = min;
p.enumList = names;
p.group = upcomingGroup;
setColorForParam(p, c);
p.intVal = *param = ofClamp(*param, min, max);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Enum Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, int* param, int min, int max, string* names, ofColor c ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_ENUM;
p.intValAddr = param;
p.maxInt = max;
p.minInt = min;
vector<string> list;
for(int i = min; i <= max; i++){
list.push_back(names[i - min]);
}
p.enumList = list;
p.group = upcomingGroup;
setColorForParam(p, c);
p.intVal = *param = ofClamp(*param, min, max);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Enum Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, string* param, ofColor c, int nothingUseful ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_STRING;
p.stringValAddr = param;
p.stringVal = *param;
p.group = upcomingGroup;
setColorForParam(p, c);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing String Param '" << paramName << "'";
}
void ofxRemoteUIServer::shareParam(string paramName, unsigned char* param, ofColor bgColor, int nothingUseful){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_COLOR;
p.redValAddr = param;
p.redVal = param[0];
p.greenVal = param[1];
p.blueVal = param[2];
p.alphaVal = param[3];
p.group = upcomingGroup;
setColorForParam(p, bgColor);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Color Param '" << paramName << "'";
}
void ofxRemoteUIServer::connect(string ipAddress, int port){
avgTimeSinceLastReply = timeSinceLastReply = timeCounter = 0.0f;
waitingForReply = false;
//params.clear();
oscSender.setup(ipAddress, port);
readyToSend = true;
}
void ofxRemoteUIServer::sendLogToClient(const char* format, ...){
if(readyToSend){
// protect from crashes or memory issues
if (strlen(format) >= 1024) {
RUI_LOG_ERROR << "ofxRemoteUIServer log string must be under 1024 chars" << endl;
return;
}
char line[1024];
va_list args;
va_start(args, format);
vsprintf(line, format, args);
sendLogToClient(string(line));
}
}
void ofxRemoteUIServer::sendLogToClient(string message){
if(readyToSend){
ofxOscMessage m;
m.setAddress("LOG_");
m.addStringArg(message);
try{
oscSender.sendMessage(m);
}catch(exception e){
RUI_LOG_ERROR << "exception " << e.what() ;
}
}
}
report on puish even if not connected
//
// ofxRemoteUI.cpp
// emptyExample
//
// Created by Oriol Ferrer Mesià on 09/01/13.
//
//
#ifdef TARGET_WIN32
#include <winsock2.h>
#endif
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#ifdef __APPLE__
#include "dirent.h"
#include <mach-o/dyld.h> /* _NSGetExecutablePath */
#elif _WIN32 || _WIN64
#include "dirent_vs.h"
#endif
#include <sys/stat.h>
#include <time.h>
#include "ofxRemoteUIServer.h"
#ifdef OF_AVAILABLE
#include <Poco/Path.h>
#include <Poco/Environment.h>
#include <Poco/Process.h>
#include <Poco/Util/Application.h>
using Poco::Util::Application;
#endif
ofxRemoteUIServer* ofxRemoteUIServer::singleton = NULL;
ofxRemoteUIServer* ofxRemoteUIServer::instance(){
if (!singleton){ // Only allow one instance of class to be generated.
singleton = new ofxRemoteUIServer();
}
return singleton;
}
void ofxRemoteUIServer::setEnabled(bool enabled_){
enabled = enabled_;
}
void ofxRemoteUIServer::setAutomaticBackupsEnabled(bool enabled){
autoBackups = enabled;
}
void ofxRemoteUIServer::setDrawsNotificationsAutomaticallly(bool draw){
drawNotifications = draw;
}
void ofxRemoteUIServer::setShowInterfaceKey(char k){
showInterfaceKey = k;
}
ofxRemoteUIServer::ofxRemoteUIServer(){
enabled = true;
readyToSend = false;
saveToXmlOnExit = true;
autoBackups = false; //off by default
broadcastTime = OFXREMOTEUI_BORADCAST_INTERVAL + 0.05;
timeSinceLastReply = avgTimeSinceLastReply = 0;
waitingForReply = false;
colorSet = false;
computerName = binaryName = "";
directoryPrefix = "";
callBack = NULL;
upcomingGroup = OFXREMOTEUI_DEFAULT_PARAM_GROUP;
verbose_ = false;
threadedUpdate = false;
drawNotifications = true;
showUI = false;
loadedFromXML = false;
clearXmlOnSaving = false;
//add random colors to table
colorTableIndex = 0;
broadcastCount = 0;
newColorInGroupCounter = 1;
showInterfaceKey = '\t';
int a = 80;
#ifdef OF_AVAILABLE
uiColumnWidth = 320;
uiAlpha = 1.0f;
selectedPreset = selectedGroupPreset = 0;
selectedItem = -1;
ofSeedRandom(1979);
ofColor prevColor = ofColor::fromHsb(35, 255, 200, BG_COLOR_ALPHA);
for(int i = 0; i < 30; i++){
ofColor c = ofColor::fromHsb(prevColor.getHue() + 10, 255, 210, BG_COLOR_ALPHA);
colorTables.push_back( c );
prevColor = c;
}
//shuffle
std::srand(1979);
std::random_shuffle ( colorTables.begin(), colorTables.end() );
ofSeedRandom();
uiLines.setMode(OF_PRIMITIVE_LINES);
#else
colorTables.push_back(ofColor(194,144,221,a) );
colorTables.push_back(ofColor(202,246,70,a) );
colorTables.push_back(ofColor(74,236,173,a) );
colorTables.push_back(ofColor(253,144,150,a) );
colorTables.push_back(ofColor(41,176,238,a) );
colorTables.push_back(ofColor(180,155,45,a) );
colorTables.push_back(ofColor(63,216,92,a) );
colorTables.push_back(ofColor(226,246,139,a) );
colorTables.push_back(ofColor(239,209,46,a) );
colorTables.push_back(ofColor(234,127,169,a) );
colorTables.push_back(ofColor(227,184,233,a) );
colorTables.push_back(ofColor(165,154,206,a) );
#endif
}
ofxRemoteUIServer::~ofxRemoteUIServer(){
RUI_LOG_VERBOSE << "~ofxRemoteUIServer()" ;
}
void ofxRemoteUIServer::setSaveToXMLOnExit(bool save){
saveToXmlOnExit = save;
}
void ofxRemoteUIServer::setCallback( void (*callb)(RemoteUIServerCallBackArg) ){
callBack = callb;
}
void ofxRemoteUIServer::close(){
if(readyToSend)
sendCIAO();
if(threadedUpdate){
#ifdef OF_AVAILABLE
stopThread();
RUI_LOG_NOTICE << "ofxRemoteUIServer closing; waiting for update thread to end..." ;
waitForThread();
#endif
}
}
void ofxRemoteUIServer::setParamGroup(string g){
upcomingGroup = g;
newColorInGroupCounter = 1;
setNewParamColor(1);
setNewParamColorVariation(true);
addSpacer(g);
}
void ofxRemoteUIServer::unsetParamColor(){
colorSet = false;
}
void ofxRemoteUIServer::setNewParamColorVariation(bool dontChangeVariation){
paramColorCurrentVariation = paramColor;
if(!dontChangeVariation){
newColorInGroupCounter++;
}
int offset = newColorInGroupCounter%2;
paramColorCurrentVariation.a = BG_COLOR_ALPHA + offset * BG_COLOR_ALPHA * 0.75;
}
void ofxRemoteUIServer::setNewParamColor(int num){
for(int i = 0; i < num; i++){
ofColor c = colorTables[colorTableIndex];
colorSet = true;
paramColor = c;
colorTableIndex++;
if(colorTableIndex>= colorTables.size()){
colorTableIndex = 0;
}
}
}
void ofxRemoteUIServer::removeParamFromDB(string paramName){
unordered_map<string, RemoteUIParam>::iterator it = params.find(paramName);
if (it != params.end()){
params.erase(params.find(paramName));
it = paramsFromCode.find(paramName);
if (it != paramsFromCode.end()){
paramsFromCode.erase(paramsFromCode.find(paramName));
}
it = paramsFromXML.find(paramName);
if (it != paramsFromXML.end()){
paramsFromXML.erase(paramsFromXML.find(paramName));
}
//re-create orderedKeys
vector<string> myOrderedKeys;
unordered_map<int, string>::iterator iterator;
for(iterator = orderedKeys.begin(); iterator != orderedKeys.end(); iterator++) {
if (iterator->second != paramName){
//positionsToDelete.push_back(iterator->first);
myOrderedKeys.push_back(iterator->second);
}
}
orderedKeys.clear();
for(int i = 0; i < myOrderedKeys.size(); i++){
orderedKeys[i] = myOrderedKeys[i];
}
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer::removeParamFromDB >> trying to delete an unexistant param (" << paramName << ")" ;
}
}
void ofxRemoteUIServer::setDirectoryPrefix(string _directoryPrefix){
directoryPrefix = _directoryPrefix;
RUI_LOG_NOTICE << "ofxRemoteUIServer: directoryPrefix set to '" << directoryPrefix << "'";
#ifdef OF_AVAILABLE
ofDirectory d;
d.open(getFinalPath(OFXREMOTEUI_PRESET_DIR));
if(!d.exists()){
d.create(true);
}
#endif
}
void ofxRemoteUIServer::saveParamToXmlSettings(RemoteUIParam t, string key, ofxXmlSettings & s, XmlCounter & c){
switch (t.type) {
case REMOTEUI_PARAM_FLOAT:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.floatValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, (double)*t.floatValAddr, c.numFloats);
s.setAttribute(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numFloats);
c.numFloats++;
break;
case REMOTEUI_PARAM_INT:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.intValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_INT_PARAM_XML_TAG, (int)*t.intValAddr, c.numInts);
s.setAttribute(OFXREMOTEUI_INT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numInts);
c.numInts++;
break;
case REMOTEUI_PARAM_COLOR:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << (int)*t.redValAddr << " " << (int)*(t.redValAddr+1) << " " << (int)*(t.redValAddr+2) << " " << (int)*(t.redValAddr+3) << ") to XML" ;
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":R", (int)*t.redValAddr, c.numColors);
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":G", (int)*(t.redValAddr+1), c.numColors);
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":B", (int)*(t.redValAddr+2), c.numColors);
s.setValue(string(OFXREMOTEUI_COLOR_PARAM_XML_TAG) + ":A", (int)*(t.redValAddr+3), c.numColors);
s.setAttribute(OFXREMOTEUI_COLOR_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numColors);
c.numColors++;
break;
case REMOTEUI_PARAM_ENUM:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.intValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_ENUM_PARAM_XML_TAG, (int)*t.intValAddr, c.numEnums);
s.setAttribute(OFXREMOTEUI_ENUM_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numEnums);
c.numEnums++;
break;
case REMOTEUI_PARAM_BOOL:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.boolValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_BOOL_PARAM_XML_TAG, (bool)*t.boolValAddr, c.numBools);
s.setAttribute(OFXREMOTEUI_BOOL_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numBools);
c.numBools++;
break;
case REMOTEUI_PARAM_STRING:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer saving '" << key << "' (" << *t.stringValAddr <<") to XML" ;
s.setValue(OFXREMOTEUI_STRING_PARAM_XML_TAG, (string)*t.stringValAddr, c.numStrings);
s.setAttribute(OFXREMOTEUI_STRING_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, key, c.numStrings);
c.numStrings++;
break;
case REMOTEUI_PARAM_SPACER:
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer skipping save of spacer '" << key << "' to XML" ;
break;
default:
break;
}
}
void ofxRemoteUIServer::saveGroupToXML(string fileName, string groupName){
#ifdef OF_AVAILABLE
fileName = getFinalPath(fileName);
ofDirectory d;
string path = getFinalPath(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName);
d.open(path);
if(!d.exists()){
d.create(true);
}
#else
#if defined(_WIN32)
_mkdir(path.c_str());
#else
mkdir(fileName.c_str(), 0777);
#endif
#endif
RUI_LOG_NOTICE << "ofxRemoteUIServer: saving group to xml '" << fileName << "'" ;
ofxXmlSettings s;
s.loadFile(fileName);
s.clear();
s.addTag(OFXREMOTEUI_XML_TAG);
s.pushTag(OFXREMOTEUI_XML_TAG);
XmlCounter counters;
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
RemoteUIParam t = params[key];
if( t.group != OFXREMOTEUI_DEFAULT_PARAM_GROUP && t.group == groupName ){
saveParamToXmlSettings(t, key, s, counters);
}
}
s.saveFile(fileName);
}
void ofxRemoteUIServer::saveToXML(string fileName){
saveSettingsBackup(); //every time , before we save
#ifdef OF_AVAILABLE
fileName = getFinalPath(fileName);
#endif
RUI_LOG_NOTICE << "ofxRemoteUIServer: saving to xml '" << fileName << "'" ;
ofxXmlSettings s;
s.loadFile(fileName);
if(clearXmlOnSaving){
s.clear();
}
if (s.getNumTags(OFXREMOTEUI_XML_TAG) == 0){
s.addTag(OFXREMOTEUI_XML_TAG);
}
s.pushTag(OFXREMOTEUI_XML_TAG);
XmlCounter counters;
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
RemoteUIParam t = params[key];
saveParamToXmlSettings(t, key, s, counters);
}
s.popTag(); //pop OFXREMOTEUI_XML_TAG
if(!portIsSet){
s.setValue(OFXREMOTEUI_XML_PORT, port, 0);
}
s.saveFile(fileName);
}
vector<string> ofxRemoteUIServer::loadFromXML(string fileName){
#ifdef OF_AVAILABLE
fileName = getFinalPath(fileName);
#endif
vector<string> loadedParams;
ofxXmlSettings s;
bool exists = s.loadFile(fileName);
if (exists){
if( s.getNumTags(OFXREMOTEUI_XML_TAG) > 0 ){
s.pushTag(OFXREMOTEUI_XML_TAG, 0);
int numFloats = s.getNumTags(OFXREMOTEUI_FLOAT_PARAM_XML_TAG);
for (int i=0; i< numFloats; i++){
string paramName = s.getAttribute(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_FLOAT_PARAM_XML_TAG, 0.0, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].floatValAddr != NULL){
*params[paramName].floatValAddr = val;
params[paramName].floatVal = val;
*params[paramName].floatValAddr = ofClamp(*params[paramName].floatValAddr, params[paramName].minFloat, params[paramName].maxFloat);
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a FLOAT '" << paramName <<"' (" << ofToString( *params[paramName].floatValAddr, 3) << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading FLOAT (" << paramName << ")" ;
}
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer: float param '" <<paramName << "' defined in xml not found in DB!" ;
}
}
int numInts = s.getNumTags(OFXREMOTEUI_INT_PARAM_XML_TAG);
for (int i=0; i< numInts; i++){
string paramName = s.getAttribute(OFXREMOTEUI_INT_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_INT_PARAM_XML_TAG, 0, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].intValAddr != NULL){
*params[paramName].intValAddr = val;
params[paramName].intVal = val;
*params[paramName].intValAddr = ofClamp(*params[paramName].intValAddr, params[paramName].minInt, params[paramName].maxInt);
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading an INT '" << paramName <<"' (" << (int) *params[paramName].intValAddr << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading INT (" << paramName << ")" ;
}
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer: int param '" <<paramName << "' defined in xml not found in DB!" ;
}
}
int numColors = s.getNumTags(OFXREMOTEUI_COLOR_PARAM_XML_TAG);
for (int i=0; i< numColors; i++){
string paramName = s.getAttribute(OFXREMOTEUI_COLOR_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, "OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY", i);
s.pushTag(OFXREMOTEUI_COLOR_PARAM_XML_TAG, i);
int r = s.getValue("R", 0);
int g = s.getValue("G", 0);
int b = s.getValue("B", 0);
int a = s.getValue("A", 0);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].redValAddr != NULL){
*params[paramName].redValAddr = r;
params[paramName].redVal = r;
*(params[paramName].redValAddr+1) = g;
params[paramName].greenVal = g;
*(params[paramName].redValAddr+2) = b;
params[paramName].blueVal = b;
*(params[paramName].redValAddr+3) = a;
params[paramName].alphaVal = a;
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a COLOR '" << paramName <<"' (" << (int)*params[paramName].redValAddr << " " << (int)*(params[paramName].redValAddr+1) << " " << (int)*(params[paramName].redValAddr+2) << " " << (int)*(params[paramName].redValAddr+3) << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading COLOR (" << paramName << ")" ;
}
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: color param '" <<paramName << "' defined in xml not found in DB!" ;
}
s.popTag();
}
int numEnums = s.getNumTags(OFXREMOTEUI_ENUM_PARAM_XML_TAG);
for (int i=0; i< numEnums; i++){
string paramName = s.getAttribute(OFXREMOTEUI_ENUM_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_ENUM_PARAM_XML_TAG, 0, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].intValAddr != NULL){
*params[paramName].intValAddr = val;
params[paramName].intVal = val;
*params[paramName].intValAddr = ofClamp(*params[paramName].intValAddr, params[paramName].minInt, params[paramName].maxInt);
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading an ENUM '" << paramName <<"' (" << (int) *params[paramName].intValAddr << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading ENUM (" << paramName << ")" ;
}
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: enum param '" << paramName << "' defined in xml not found in DB!" ;
}
}
int numBools = s.getNumTags(OFXREMOTEUI_BOOL_PARAM_XML_TAG);
for (int i=0; i< numBools; i++){
string paramName = s.getAttribute(OFXREMOTEUI_BOOL_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
float val = s.getValue(OFXREMOTEUI_BOOL_PARAM_XML_TAG, false, i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].boolValAddr != NULL){
*params[paramName].boolValAddr = val;
params[paramName].boolVal = val;
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a BOOL '" << paramName <<"' (" << (bool) *params[paramName].boolValAddr << ") from XML" ;
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading BOOL (" << paramName << ")" ;
}
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: bool param '" << paramName << "' defined in xml not found in DB!" ;
}
}
int numStrings = s.getNumTags(OFXREMOTEUI_STRING_PARAM_XML_TAG);
for (int i=0; i< numStrings; i++){
string paramName = s.getAttribute(OFXREMOTEUI_STRING_PARAM_XML_TAG, OFXREMOTEUI_PARAM_NAME_XML_KEY, OFXREMOTEUI_UNKNOWN_PARAM_NAME_XML_KEY, i);
string val = s.getValue(OFXREMOTEUI_STRING_PARAM_XML_TAG, "", i);
unordered_map<string,RemoteUIParam>::iterator it = params.find(paramName);
if ( it != params.end() ){ // found!
loadedParams.push_back(paramName);
if(params[paramName].stringValAddr != NULL){
params[paramName].stringVal = val;
*params[paramName].stringValAddr = val;
if(!loadedFromXML) paramsFromXML[paramName] = params[paramName];
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer loading a STRING '" << paramName <<"' (" << (string) *params[paramName].stringValAddr << ") from XML" ;
}
else RUI_LOG_ERROR << "ofxRemoteUIServer ERROR at loading STRING (" << paramName << ")" ;
}else{
RUI_LOG_WARNING << "ofxRemoteUIServer: string param '" << paramName << "' defined in xml not found in DB!" ;
}
}
}
}
vector<string> paramsNotInXML;
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string paramName = (*ii).first;
//param name found in xml
if( find(loadedParams.begin(), loadedParams.end(), paramName) != loadedParams.end() ){
}else{ //param name not in xml
if ((*ii).second.type != REMOTEUI_PARAM_SPACER){ //spacers dont count as params really
paramsNotInXML.push_back(paramName);
}
}
}
loadedFromXML = true;
return paramsNotInXML;
}
void ofxRemoteUIServer::restoreAllParamsToInitialXML(){
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
if (params[key].type != REMOTEUI_PARAM_SPACER){
params[key] = paramsFromXML[key];
syncPointerToParam(key);
}
}
}
void ofxRemoteUIServer::restoreAllParamsToDefaultValues(){
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
string key = (*ii).first;
params[key] = paramsFromCode[key];
syncPointerToParam(key);
}
}
void ofxRemoteUIServer::pushParamsToClient(){
vector<string>changedParams = scanForUpdatedParamsAndSync();
#ifdef OF_AVAILABLE
for(int i = 0 ; i < changedParams.size(); i++){
string pName = changedParams[i];
RemoteUIParam p = params[pName];
onScreenNotifications.addParamUpdate(pName, p.getValueAsString(),
p.type == REMOTEUI_PARAM_COLOR ?
ofColor(p.redVal, p.greenVal, p.blueVal, p.alphaVal) :
ofColor(0,0,0,0)
);
}
#endif
if(readyToSend){
vector<string>paramsList = getAllParamNamesList();
syncAllParamsToPointers();
sendUpdateForParamsInList(paramsList);
sendREQU(true); //once all send, confirm to close the REQU
}
}
void ofxRemoteUIServer::setNetworkInterface(string iface){
userSuppliedNetInterface = iface;
}
string ofxRemoteUIServer::getFinalPath(string p){
if(directoryPrefix.size()){
stringstream ss;
ss << directoryPrefix << "/" << p;
p = ss.str();
}
return p;
}
void ofxRemoteUIServer::saveSettingsBackup(){
#ifdef OF_AVAILABLE
if(autoBackups){
ofDirectory d;
d.open( getFinalPath(OFXREMOTEUI_SETTINGS_BACKUP_FOLDER) );
if (!d.exists()){
ofDirectory::createDirectory(getFinalPath(OFXREMOTEUI_SETTINGS_BACKUP_FOLDER));
}d.close();
string basePath = OFXREMOTEUI_SETTINGS_BACKUP_FOLDER + string("/") + ofFilePath::removeExt(OFXREMOTEUI_SETTINGS_FILENAME) + ".";
basePath = getFinalPath(basePath);
for (int i = OFXREMOTEUI_NUM_BACKUPS - 1; i >= 0; i--){
string originalPath = basePath + ofToString(i) + ".xml";
string destPath = basePath + ofToString(i+1) + ".xml";
ofFile og;
og.open(originalPath);
if ( og.exists() ){
try{
ofFile::moveFromTo(originalPath, destPath, true, true); //TODO complains on windows!
}catch(...){}
}
og.close();
}
ofFile f;
f.open(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME));
if(f.exists()){
try{
ofFile::copyFromTo(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME), basePath + "0.xml");
}catch(...){}
}
f.close();
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer saving a backup of the current " << getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME) << " in " << getFinalPath(OFXREMOTEUI_SETTINGS_BACKUP_FOLDER) ;
}
#endif
}
void ofxRemoteUIServer::setup(int port_, float updateInterval_){
#ifdef OF_AVAILABLE
ofDirectory d;
d.open(getFinalPath(OFXREMOTEUI_PRESET_DIR));
if(!d.exists()){
d.create(true);
}
#else
#if defined(_WIN32)
_mkdir(getFinalPath(OFXREMOTEUI_PRESET_DIR));
#else
mkdir(getFinalPath(OFXREMOTEUI_PRESET_DIR).c_str(), (mode_t)0777);
#endif
#endif
//check for enabled
string configFile;
#ifdef OF_AVAILABLE
ofxXmlSettings s;
configFile = ofToDataPath(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME));
bool exists = s.loadFile(configFile);
if(exists){
if( s.getNumTags(OFXREMOTEUI_XML_ENABLED) > 0 ){
enabled = ("true" == s.getValue(OFXREMOTEUI_XML_ENABLED, "true"));
if (!enabled){
RUI_LOG_WARNING << "ofxRemoteUIServer launching disabled!" ;
}
}
}
#else
configFile = getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME);
enabled = true;
#endif
if(enabled){
//setup the broadcasting
computerIP = getMyIP(userSuppliedNetInterface);
doBroadcast = true;
string multicastIP;
if (computerIP != RUI_LOCAL_IP_ADDRESS){
vector<string>comps;
split(comps, computerIP, '.');
multicastIP = comps[0] + "." + comps[1] + "." + comps[2] + "." + "255";
}else{
multicastIP = "255.255.255.255";
}
broadcastSender.setup( multicastIP, OFXREMOTEUI_BROADCAST_PORT ); //multicast @
RUI_LOG_NOTICE << "ofxRemoteUIServer: letting everyone know that I am at " << multicastIP << ":" << OFXREMOTEUI_BROADCAST_PORT ;
if(port_ == -1){ //if no port specified, pick a random one, but only the very first time we get launched!
portIsSet = false;
ofxXmlSettings s;
bool exists = s.loadFile(configFile);
bool portNeedsToBePicked = false;
if (exists){
if( s.getNumTags(OFXREMOTEUI_XML_PORT) > 0 ){
port_ = s.getValue(OFXREMOTEUI_XML_PORT, 10000);
}else{
portNeedsToBePicked = true;
}
}else{
portNeedsToBePicked = true;
}
if(portNeedsToBePicked){
#ifdef OF_AVAILABLE
ofSeedRandom();
port_ = ofRandom(5000, 60000);
#else
srand (time(NULL));
port_ = 5000 + rand()%55000;
#endif
ofxXmlSettings s2;
s2.loadFile(getFinalPath(OFXREMOTEUI_SETTINGS_FILENAME));
s2.setValue(OFXREMOTEUI_XML_PORT, port_, 0);
s2.saveFile();
}
}else{
portIsSet = true;
}
params.clear();
updateInterval = updateInterval_;
waitingForReply = false;
avgTimeSinceLastReply = timeSinceLastReply = timeCounter = 0.0f;
port = port_;
RUI_LOG_NOTICE << "ofxRemoteUIServer listening at port " << port << " ... " ;
oscReceiver.setup(port);
}
//still get ui access despite being disabled
#ifdef OF_AVAILABLE
ofAddListener(ofEvents().exit, this, &ofxRemoteUIServer::_appExited); //to save to xml, disconnect, etc
ofAddListener(ofEvents().keyPressed, this, &ofxRemoteUIServer::_keyPressed);
ofAddListener(ofEvents().update, this, &ofxRemoteUIServer::_update);
ofAddListener(ofEvents().draw, this, &ofxRemoteUIServer::_draw);
#endif
}
#ifdef OF_AVAILABLE
void ofxRemoteUIServer::_appExited(ofEventArgs &e){
if(!enabled) return;
OFX_REMOTEUI_SERVER_CLOSE(); //stop the server
if(saveToXmlOnExit){
OFX_REMOTEUI_SERVER_SAVE_TO_XML(); //save values to XML
}
}
void ofxRemoteUIServer::_keyPressed(ofKeyEventArgs &e){
if (showUI){
switch(e.key){ //you can save current config from tab screen by pressing s
case 's':
saveToXML(OFXREMOTEUI_SETTINGS_FILENAME);
onScreenNotifications.addNotification("SAVED CONFIG to default XML");
break;
case 'S':{
bool groupIsSelected = false;
string groupName;
if (selectedItem >= 0){ //selection on params list
string key = orderedKeys[selectedItem];
RemoteUIParam p = params[key];
if (p.type == REMOTEUI_PARAM_SPACER){
groupIsSelected = true;
groupName = p.group;
}
}
string presetName = ofSystemTextBoxDialog(groupIsSelected ?
"Create a New Group Preset For " + groupName
:
"Create a New Global Preset" ,
"");
if(presetName.size()){
RemoteUIServerCallBackArg cbArg;
if (groupIsSelected){
saveGroupToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName + "/" + presetName + ".xml", groupName);
if(callBack) callBack(cbArg);
cbArg.action = CLIENT_SAVED_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
#ifdef OF_AVAILABLE
ofNotifyEvent(clientAction, cbArg, this);
onScreenNotifications.addNotification("SAVED PRESET '" + presetName + ".xml' FOR GROUP '" + groupName + "'");
#endif
}else{
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: saving NEW preset: " << presetName ;
saveToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
cbArg.action = CLIENT_SAVED_PRESET;
cbArg.msg = presetName;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack) callBack(cbArg);
}
refreshPresetsCache();
}
}break;
case 'r':
restoreAllParamsToInitialXML();
onScreenNotifications.addNotification("RESET CONFIG TO SERVER-LAUNCH XML values");
break;
case OF_KEY_RETURN:
if(selectedItem == -1 && selectedPreset >= 0){ //global presets
lastChosenPreset = presetsCached[selectedPreset];
loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + lastChosenPreset + ".xml");
syncAllPointersToParams();
uiAlpha = 0;
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset: " << lastChosenPreset ;
RemoteUIServerCallBackArg cbArg;
cbArg.action = CLIENT_DID_SET_PRESET;
cbArg.msg = lastChosenPreset;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SET PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + lastChosenPreset + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
}
if (selectedItem >= 0){ //selection on params list
string key = orderedKeys[selectedItem];
RemoteUIParam p = params[key];
if(p.type == REMOTEUI_PARAM_SPACER && groupPresetsCached[p.group].size() > 0){
string presetName = p.group + "/" + groupPresetsCached[p.group][selectedGroupPreset];
loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
syncAllPointersToParams();
uiAlpha = 0;
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset: " << presetName ;
RemoteUIServerCallBackArg cbArg;
cbArg.action = CLIENT_DID_SET_GROUP_PRESET;
cbArg.msg = p.group;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
ofNotifyEvent(clientAction, cbArg, this);
onScreenNotifications.addNotification("SET '" + p.group + "' GROUP TO '" + presetName + ".xml' PRESET");
#endif
}
}
break;
case OF_KEY_DOWN:
case OF_KEY_UP:{
float sign = e.key == OF_KEY_DOWN ? 1.0 : -1.0;
selectedGroupPreset = 0;
uiAlpha = 1;
selectedItem += sign;
if(selectedItem < -1) selectedItem = orderedKeys.size() - 1;
if(selectedItem >= orderedKeys.size()) selectedItem = -1; //presets menu >> selectedItem = -1, on top of all
selectedGroupPreset = 0;
}break;
case OF_KEY_LEFT:
case OF_KEY_RIGHT:{
float sign = e.key == OF_KEY_RIGHT ? 1.0 : -1.0;
if (selectedItem >= 0){ //params
string key = orderedKeys[selectedItem];
RemoteUIParam p = params[key];
if (p.type != REMOTEUI_PARAM_SPACER){
uiAlpha = 0;
switch (p.type) {
case REMOTEUI_PARAM_FLOAT:
p.floatVal += sign * (p.maxFloat - p.minFloat) * 0.0025;
p.floatVal = ofClamp(p.floatVal, p.minFloat, p.maxFloat);
break;
case REMOTEUI_PARAM_ENUM:
case REMOTEUI_PARAM_INT:
p.intVal += sign;
p.intVal = ofClamp(p.intVal, p.minInt, p.maxInt);
break;
case REMOTEUI_PARAM_BOOL:
p.boolVal = !p.boolVal;
break;
default:
break;
}
params[key] = p;
syncPointerToParam(key);
pushParamsToClient();
RemoteUIServerCallBackArg cbArg;
cbArg.action = CLIENT_DID_RESET_TO_XML;
cbArg.host = "localhost";
cbArg.action = CLIENT_UPDATED_PARAM;
cbArg.paramName = key;
cbArg.param = params[key]; //copy the updated param to the callbakc arg
#ifdef OF_AVAILABLE
onScreenNotifications.addParamUpdate(key, cbArg.param.getValueAsString());
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack) callBack(cbArg);
}else{ //in spacer! group time, cycle through group presets
int numGroupPresets = groupPresetsCached[p.group].size();
if(numGroupPresets > 0){
selectedGroupPreset += sign;
if (selectedGroupPreset < 0) selectedGroupPreset = numGroupPresets -1;
if (selectedGroupPreset > numGroupPresets -1) selectedGroupPreset = 0;
}
}
}else{ //presets!
if (presetsCached.size()){
selectedPreset += sign;
int limit = presetsCached.size() - 1;
if (selectedPreset > limit){
selectedPreset = 0;
}
if (selectedPreset < 0){
selectedPreset = limit;
}
}
}
}break;
}
}
if(e.key == showInterfaceKey){
if (uiAlpha < 1.0 && showUI){
uiAlpha = 1.0;
showUI = false;
}else{
showUI = !showUI;
}
if (showUI){
uiAlpha = 1;
uiLines.clear();
syncAllPointersToParams();
refreshPresetsCache();
}
}
}
void ofxRemoteUIServer::refreshPresetsCache(){
//get all group presets
groupPresetsCached.clear();
for( unordered_map<string,RemoteUIParam>::iterator ii = params.begin(); ii != params.end(); ++ii ){
if((*ii).second.type == REMOTEUI_PARAM_SPACER){
groupPresetsCached[(*ii).second.group] = getAvailablePresetsForGroup((*ii).second.group);
};
}
presetsCached = getAvailablePresets(true);
if (selectedPreset > presetsCached.size() -1){
selectedPreset = 0;
}
}
void ofxRemoteUIServer::startInBackgroundThread(){
threadedUpdate = true;
startThread();
}
#endif
void ofxRemoteUIServer::update(float dt){
#ifdef OF_AVAILABLE
if(!threadedUpdate){
updateServer(dt);
}
uiAlpha += 0.3 * ofGetLastFrameTime();
if(uiAlpha > 1) uiAlpha = 1;
#else
updateServer(dt);
#endif
}
#ifdef OF_AVAILABLE
void ofxRemoteUIServer::threadedFunction(){
while (isThreadRunning()) {
updateServer(1./30.); //30 fps timebase
ofSleepMillis(33);
}
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer threadedFunction() ending" ;
}
void ofxRemoteUIServer::_draw(ofEventArgs &e){
ofSetupScreen(); //mmm this is a bit scary //TODO!
draw( 20, ofGetHeight() - 20);
}
void ofxRemoteUIServer::_update(ofEventArgs &e){
update(ofGetLastFrameTime());
}
void ofxRemoteUIServer::draw(int x, int y){
ofPushStyle();
ofFill();
ofEnableAlphaBlending();
if(showUI){
int padding = 30;
int x = padding;
int initialY = padding * 1.5;
int y = initialY;
int colw = uiColumnWidth;
int realColW = colw * 0.9;
int valOffset = realColW * 0.7;
int valSpaceW = realColW - valOffset;
int spacing = 20;
int bottomBarHeight = padding + spacing + 36;
//bottom bar
if (uiAlpha > 0.99){
ofSetColor(11, 245 * uiAlpha);
ofRect(0,0, ofGetWidth(), ofGetHeight());
ofSetColor(44, 245);
ofRect(0,ofGetHeight() - bottomBarHeight, ofGetWidth(), bottomBarHeight );
ofSetColor(255);
ofDrawBitmapString("ofxRemoteUI built in client. " +
string(enabled ? ("Server reachable at " + computerIP + ":" + ofToString(port)) + "." :
"Sever Disabled." ) +
"\nPress 's' to save current config.\n" +
"Press 'S' to make a new preset.\n" +
"Press 'r' to restore all param's launch state.\n" +
"Use Arrow Keys to edit values. Press 'TAB' to hide.", padding, ofGetHeight() - bottomBarHeight + 20);
}
//preset selection / top bar
ofSetColor(64);
ofRect(0 , 0, ofGetWidth(), 22);
ofColor textBlinkC ;
if(ofGetFrameNum()%5 < 1) textBlinkC = ofColor(255);
else textBlinkC = ofColor(255,0,0);
if(presetsCached.size() > 0 && selectedPreset >= 0 && selectedPreset < presetsCached.size()){
ofVec2f dpos = ofVec2f(192, 16);
ofSetColor(180);
if (selectedItem < 0){
ofDrawBitmapString("Press RETURN to load GLOBAL PRESET: \"" + presetsCached[selectedPreset] + "\"", dpos);
ofSetColor(textBlinkC);
ofDrawBitmapString(" " + presetsCached[selectedPreset], dpos);
}else{
RemoteUIParam p = params[orderedKeys[selectedItem]];
int howMany = 0;
if(p.type == REMOTEUI_PARAM_SPACER){
howMany = groupPresetsCached[p.group].size();
if (howMany > 0){
string msg = "Press RETURN to load \"" + p.group + "\" GROUP PRESET: \"";
ofDrawBitmapString( msg + groupPresetsCached[p.group][selectedGroupPreset] + "\"", dpos);
ofSetColor(textBlinkC);
ofDrawBitmapString(groupPresetsCached[p.group][selectedGroupPreset],
dpos + ofVec2f(msg.length() * 8, 0));
}
}
if(howMany == 0){
ofSetColor(180);
ofDrawBitmapString("Selected Preset: NONE", dpos);
}
}
}
if (selectedItem != -1) ofSetColor(255);
else ofSetColor(textBlinkC);
ofDrawBitmapString("+ PRESET SELECTION: " , 30, 16);
int linesInited = uiLines.getNumVertices() > 0 ;
if(uiAlpha > 0.99){
//param list
for(int i = 0; i < orderedKeys.size(); i++){
string key = orderedKeys[i];
RemoteUIParam p = params[key];
int chars = key.size();
int charw = 9;
int column2MaxLen = ceil(valSpaceW / charw) + 1;
int stringw = chars * charw;
if (stringw > valOffset){
key = key.substr(0, (valOffset) / charw );
}
if (selectedItem != i){
ofSetColor(p.r, p.g, p.b);
}else{
if(ofGetFrameNum()%5 < 1) ofSetColor(222);
else ofSetColor(255,0,0);
}
if(p.type != REMOTEUI_PARAM_SPACER){
string sel = (selectedItem == i) ? ">>" : " ";
ofDrawBitmapString(sel + key, x, y);
}else{
ofPushStyle();
ofColor c = ofColor(p.r, p.g, p.b);
ofSetColor(c * 0.3);
ofRect(x , -spacing + y + spacing * 0.33, realColW, spacing);
ofPopStyle();
ofDrawBitmapString("+ " + p.stringVal, x,y);
}
switch (p.type) {
case REMOTEUI_PARAM_FLOAT:
ofDrawBitmapString(ofToString(p.floatVal), x + valOffset, y);
break;
case REMOTEUI_PARAM_ENUM:
if (p.intVal >= 0 && p.intVal < p.enumList.size() && p.enumList.size() > 0){
string val = p.enumList[p.intVal];
if (val.length() > column2MaxLen){
val = val.substr(0, column2MaxLen);
}
ofDrawBitmapString(val, x + valOffset, y);
}else{
ofDrawBitmapString(ofToString(p.intVal), x + valOffset, y);
}
break;
case REMOTEUI_PARAM_INT:
ofDrawBitmapString(ofToString(p.intVal), x + valOffset, y);
break;
case REMOTEUI_PARAM_BOOL:
ofDrawBitmapString(p.boolVal ? "true" : "false", x + valOffset, y);
break;
case REMOTEUI_PARAM_STRING:
ofDrawBitmapString(p.stringVal, x + valOffset, y);
break;
case REMOTEUI_PARAM_COLOR:
ofSetColor(p.redVal, p.greenVal, p.blueVal, p.alphaVal);
ofRect(x + valOffset, y - spacing * 0.6, 64, spacing * 0.85);
break;
case REMOTEUI_PARAM_SPACER:{
int howMany = groupPresetsCached[p.group].size();
if (selectedItem == i){ //selected
if (selectedGroupPreset < howMany && selectedGroupPreset >= 0){
string presetName = groupPresetsCached[p.group][selectedGroupPreset];
if (presetName.length() > column2MaxLen){
presetName = presetName.substr(0, column2MaxLen);
}
ofDrawBitmapString(presetName, x + valOffset, y);
}
}else{ //not selected
if(howMany > 0 ){
ofDrawBitmapString("(" + ofToString(howMany) + ")", x + valOffset, y);
}
}
}break;
default: printf("weird RemoteUIParam at draw()!\n"); break;
}
if(!linesInited){
uiLines.addVertex(ofVec2f(x, y + spacing * 0.33));
uiLines.addVertex(ofVec2f(x + realColW, y + spacing * 0.33));
}
y += spacing;
if (y > ofGetHeight() - padding * 0.5 - bottomBarHeight){
x += colw;
y = initialY;
}
}
ofSetColor(32);
ofSetLineWidth(1);
uiLines.draw();
}
//tiny clock top left
if (uiAlpha < 1.0){
ofMesh m;
int step = 30;
m.setMode(OF_PRIMITIVE_TRIANGLE_FAN);
ofVec2f origin = ofVec2f(15,11); //rect is 22
m.addVertex(origin);
float r = 8.0f;
float ang;
float lim = 360.0f * (1.0f - uiAlpha);
for(ang = 0; ang < lim; ang += step){
m.addVertex( origin + ofVec2f( r * cosf((-90.0f + ang) * DEG_TO_RAD),
r * sinf((-90.0f + ang) * DEG_TO_RAD)));
}
float lastBit = lim - ang;
m.addVertex( origin + ofVec2f( r * cosf((-90.0f + ang + lastBit) * DEG_TO_RAD),
r * sinf((-90.0f + ang + lastBit) * DEG_TO_RAD)));
ofSetColor(128);
m.draw();
}
}
if (!showUI || uiAlpha < 1.0){
if (drawNotifications){
for(int i = 0; i < paramsToWatch.size(); i++){
onScreenNotifications.addParamWatch(paramsToWatch[i], params[paramsToWatch[i]].getValueAsStringFromPointer());
}
onScreenNotifications.draw(x, y);
}
}
ofPopStyle();
}
#endif
void ofxRemoteUIServer::handleBroadcast(){
if(doBroadcast){
if(broadcastTime > OFXREMOTEUI_BORADCAST_INTERVAL){
broadcastTime = 0.0f;
if (computerName.size() == 0){
#ifdef OF_AVAILABLE
Poco::Environment e;
computerName = e.nodeName();
char pathbuf[2048];
uint32_t bufsize = sizeof(pathbuf);
#ifdef TARGET_OSX
_NSGetExecutablePath(pathbuf, &bufsize);
Poco::Path p = Poco::Path(pathbuf);
binaryName = p[p.depth()];
#else
#ifdef TARGET_WIN32
GetModuleFileNameA( NULL, pathbuf, bufsize ); //no idea why, but GetModuleFileName() is not defined?
Poco::Path p = Poco::Path(pathbuf);
binaryName = p[p.depth()];
#else
char procname[1024];
int len = readlink("/proc/self/exe", procname, 1024-1);
if (len > 0){
procname[len] = '\0';
Poco::Path p = Poco::Path(procname);
binaryName = p[p.depth()];
}
#endif
#endif
#endif
}
ofxOscMessage m;
m.addIntArg(port); //0
m.addStringArg(computerName); //1
m.addStringArg(binaryName); //2
m.addIntArg(broadcastCount); // 3
broadcastSender.sendMessage(m);
broadcastCount++;
}
}
}
void ofxRemoteUIServer::updateServer(float dt){
#ifdef OF_AVAILABLE
onScreenNotifications.update(dt);
#endif
if(!enabled) return;
timeCounter += dt;
broadcastTime += dt;
timeSinceLastReply += dt;
if(readyToSend){
if (timeCounter > updateInterval){
timeCounter = 0.0f;
//vector<string> changes = scanForUpdatedParamsAndSync(); //sends changed params to client
//cout << "ofxRemoteUIServer: sent " << ofToString(changes.size()) << " updates to client" ;
//sendUpdateForParamsInList(changes);
}
}
//let everyone know I exist and which is my port, every now and then
handleBroadcast();
while( oscReceiver.hasWaitingMessages() ){// check for waiting messages from client
ofxOscMessage m;
oscReceiver.getNextMessage(&m);
if (!readyToSend){ // if not connected, connect to our friend so we can talk back
connect(m.getRemoteIp(), port + 1);
}
DecodedMessage dm = decode(m);
RemoteUIServerCallBackArg cbArg; // to notify our "delegate"
cbArg.host = m.getRemoteIp();
switch (dm.action) {
case HELO_ACTION: //if client says hi, say hi back
sendHELLO();
cbArg.action = CLIENT_CONNECTED;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("CONNECTED (" + cbArg.host + ")!");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " says HELLO!" ;
break;
case REQUEST_ACTION:{ //send all params to client
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " sends REQU!" ;
pushParamsToClient();
}break;
case SEND_PARAM_ACTION:{ //client is sending us an updated val
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " sends SEND!" ;
updateParamFromDecodedMessage(m, dm);
cbArg.action = CLIENT_UPDATED_PARAM;
cbArg.paramName = dm.paramName;
cbArg.param = params[dm.paramName]; //copy the updated param to the callbakc arg
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
RemoteUIParam p = params[dm.paramName];
onScreenNotifications.addParamUpdate(dm.paramName, p.getValueAsString(),
p.type == REMOTEUI_PARAM_COLOR ?
ofColor(p.redVal, p.greenVal, p.blueVal, p.alphaVal):
ofColor(0,0,0,0)
);
ofNotifyEvent(clientAction, cbArg, this);
#endif
}
break;
case CIAO_ACTION:{
sendCIAO();
cbArg.action = CLIENT_DISCONNECTED;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("DISCONNECTED (" + cbArg.host + ")!");
ofNotifyEvent(clientAction, cbArg, this);
#endif
clearOscReceiverMsgQueue();
readyToSend = false;
if(verbose_) RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " says CIAO!" ;
}break;
case TEST_ACTION: // we got a request from client, lets bounce back asap.
sendTEST();
//if(verbose)RUI_LOG_VERBOSE << "ofxRemoteUIServer: " << m.getRemoteIp() << " says TEST!" ;
break;
case PRESET_LIST_ACTION: //client wants us to send a list of all available presets
presetNames = getAvailablePresets();
if (presetNames.size() == 0){
presetNames.push_back(OFXREMOTEUI_NO_PRESETS);
}
sendPREL(presetNames);
break;
case SET_PRESET_ACTION:{ // client wants to set a preset
string presetName = m.getArgAsString(0);
vector<string> missingParams = loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
sendSETP(presetName);
sendMISP(missingParams);
cbArg.action = CLIENT_DID_SET_PRESET;
cbArg.msg = presetName;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SET PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset: " << presetName ;
}break;
case SAVE_PRESET_ACTION:{ //client wants to save current xml as a new preset
string presetName = m.getArgAsString(0);
saveToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml");
sendSAVP(presetName);
cbArg.action = CLIENT_SAVED_PRESET;
cbArg.msg = presetName;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED PRESET to '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: saving NEW preset: " << presetName ;
}break;
case DELETE_PRESET_ACTION:{
string presetName = m.getArgAsString(0);
deletePreset(presetName);
sendDELP(presetName);
cbArg.action = CLIENT_DELETED_PRESET;
cbArg.msg = presetName;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("DELETED PRESET '" + getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + presetName + ".xml'");
ofNotifyEvent(clientAction, cbArg, this);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: DELETE preset: " << presetName ;
#endif
}break;
case SAVE_CURRENT_STATE_ACTION:{
saveToXML(OFXREMOTEUI_SETTINGS_FILENAME);
cbArg.action = CLIENT_SAVED_STATE;
if(callBack) callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED CONFIG to default XML");
ofNotifyEvent(clientAction, cbArg, this);
#endif
sendSAVE(true);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: SAVE CURRENT PARAMS TO DEFAULT XML: " ;
}break;
case RESET_TO_XML_ACTION:{
restoreAllParamsToInitialXML();
sendRESX(true);
cbArg.action = CLIENT_DID_RESET_TO_XML;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("RESET CONFIG TO SERVER-LAUNCH XML values");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack)callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: RESET TO XML: " ;
}break;
case RESET_TO_DEFAULTS_ACTION:{
cbArg.action = CLIENT_DID_RESET_TO_DEFAULTS;
restoreAllParamsToDefaultValues();
sendRESD(true);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("RESET CONFIG TO DEFAULTS (source defined values)");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack)callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: RESET TO DEFAULTS: " ;
}break;
case SET_GROUP_PRESET_ACTION:{ // client wants to set a preset for a group
string presetName = m.getArgAsString(0);
string groupName = m.getArgAsString(1);
vector<string> missingParams = loadFromXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName + "/" + presetName + ".xml");
vector<string> filtered;
for(int i = 0; i < missingParams.size(); i++){
if ( params[ missingParams[i] ].group == groupName ){
filtered.push_back(missingParams[i]);
}
}
sendSETp(presetName, groupName);
sendMISP(filtered);
cbArg.action = CLIENT_DID_SET_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
if(callBack)callBack(cbArg);
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SET '" + groupName + "' GROUP TO '" + presetName + ".xml' PRESET");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: setting preset group: " << groupName << "/" <<presetName ;
}break;
case SAVE_GROUP_PRESET_ACTION:{ //client wants to save current xml as a new preset
string presetName = m.getArgAsString(0);
string groupName = m.getArgAsString(1);
saveGroupToXML(string(OFXREMOTEUI_PRESET_DIR) + "/" + groupName + "/" + presetName + ".xml", groupName);
sendSAVp(presetName, groupName);
cbArg.action = CLIENT_SAVED_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("SAVED PRESET '" + presetName + ".xml' FOR GROUP '" + groupName + "'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack) callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: saving NEW preset: " << presetName ;
}break;
case DELETE_GROUP_PRESET_ACTION:{
string presetName = m.getArgAsString(0);
string groupName = m.getArgAsString(1);
deletePreset(presetName, groupName);
sendDELp(presetName, groupName);
cbArg.action = CLIENT_DELETED_GROUP_PRESET;
cbArg.msg = presetName;
cbArg.group = groupName;
#ifdef OF_AVAILABLE
onScreenNotifications.addNotification("DELETED PRESET '" + presetName + ".xml' FOR GROUP'" + groupName + "'");
ofNotifyEvent(clientAction, cbArg, this);
#endif
if(callBack)callBack(cbArg);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer: DELETE preset: " << presetName ;
}break;
default: RUI_LOG_ERROR << "ofxRemoteUIServer::update >> ERR!"; break;
}
}
}
void ofxRemoteUIServer::deletePreset(string name, string group){
#ifdef OF_AVAILABLE
ofDirectory dir;
if (group == "")
dir.open(getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + name + ".xml");
else
dir.open(getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + group + "/" + name + ".xml");
dir.remove(true);
#else
string file = getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + name + ".xml";
if (group != "") file = getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + group + "/" + name + ".xml";
remove( file.c_str() );
#endif
}
vector<string> ofxRemoteUIServer::getAvailablePresets(bool onlyGlobal){
vector<string> presets;
#ifdef OF_AVAILABLE
ofDirectory dir;
dir.listDir(ofToDataPath(getFinalPath(OFXREMOTEUI_PRESET_DIR)));
vector<ofFile> files = dir.getFiles();
for(int i = 0; i < files.size(); i++){
string fileName = files[i].getFileName();
string extension = files[i].getExtension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (files[i].isFile() && extension == "xml"){
string presetName = fileName.substr(0, fileName.size()-4);
presets.push_back(presetName);
}
if (files[i].isDirectory() && !onlyGlobal){
ofDirectory dir2;
dir2.listDir( ofToDataPath( getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + fileName) );
vector<ofFile> files2 = dir2.getFiles();
for(int j = 0; j < files2.size(); j++){
string fileName2 = files2[j].getFileName();
string extension2 = files2[j].getExtension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (files2[j].isFile() && extension2 == "xml"){
string presetName2 = fileName2.substr(0, fileName2.size()-4);
presets.push_back(fileName + "/" + presetName2);
}
}
}
}
#else
DIR *dir2;
struct dirent *ent;
if ((dir2 = opendir(getFinalPath(OFXREMOTEUI_PRESET_DIR).c_str() )) != NULL) {
while ((ent = readdir (dir2)) != NULL) {
if ( strcmp( get_filename_ext(ent->d_name), "xml") == 0 ){
string fileName = string(ent->d_name);
string presetName = fileName.substr(0, fileName.size()-4);
presets.push_back(presetName);
}
}
closedir(dir2);
}
#endif
return presets;
}
vector<string> ofxRemoteUIServer::getAvailablePresetsForGroup(string group){
vector<string> presets;
#ifdef OF_AVAILABLE
ofDirectory dir;
string path = ofToDataPath(getFinalPath(OFXREMOTEUI_PRESET_DIR) + "/" + group );
if(ofDirectory::doesDirectoryExist(path)){
dir.listDir(path);
vector<ofFile> files = dir.getFiles();
for(int i = 0; i < files.size(); i++){
string fileName = files[i].getFileName();
string extension = files[i].getExtension();
std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
if (files[i].isFile() && extension == "xml"){
string presetName = fileName.substr(0, fileName.size()-4);
presets.push_back(presetName);
}
}
}
#endif
return presets;
}
void ofxRemoteUIServer::setColorForParam(RemoteUIParam &p, ofColor c){
if (c.a > 0){ //if user supplied a color, override the setColor
p.r = c.r; p.g = c.g; p.b = c.b; p.a = c.a;
}else{
if (colorSet){
p.r = paramColorCurrentVariation.r;
p.g = paramColorCurrentVariation.g;
p.b = paramColorCurrentVariation.b;
p.a = paramColorCurrentVariation.a;
}
}
}
void ofxRemoteUIServer::watchParamOnScreen(string paramName){
if (params.find(paramName) != params.end()){
paramsToWatch.push_back(paramName);
}else{
RUI_LOG_ERROR << "ofxRemoteUIServer can't watch that param; it doesnt exist! " << paramName << endl;
}
}
void ofxRemoteUIServer::addSpacer(string title){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_SPACER;
p.stringVal = title;
p.r = paramColor.r;
p.g = paramColor.g;
p.b = paramColor.b;
p.group = upcomingGroup; //to ignore those in the client app later when grouping
p.a = 255; //spacer has full alpha
#ifdef OF_AVAILABLE
addParamToDB(p, title + " - " + ofToString((int)ofRandom(1000000)));
#else
addParamToDB(p, title + " - " + ofToString(rand()%1000000));
#endif
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Adding Group '" << title << "' #######################" ;
}
void ofxRemoteUIServer::shareParam(string paramName, float* param, float min, float max, ofColor c){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_FLOAT;
p.floatValAddr = param;
p.maxFloat = max;
p.minFloat = min;
p.floatVal = *param = ofClamp(*param, min, max);
p.group = upcomingGroup;
setColorForParam(p, c);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Float Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, bool* param, ofColor c, int nothingUseful ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_BOOL;
p.boolValAddr = param;
p.boolVal = *param;
p.group = upcomingGroup;
setColorForParam(p, c);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Bool Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, int* param, int min, int max, ofColor c ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_INT;
p.intValAddr = param;
p.maxInt = max;
p.minInt = min;
p.group = upcomingGroup;
setColorForParam(p, c);
p.intVal = *param = ofClamp(*param, min, max);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Int Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, int* param, int min, int max, vector<string> names, ofColor c ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_ENUM;
p.intValAddr = param;
p.maxInt = max;
p.minInt = min;
p.enumList = names;
p.group = upcomingGroup;
setColorForParam(p, c);
p.intVal = *param = ofClamp(*param, min, max);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Enum Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, int* param, int min, int max, string* names, ofColor c ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_ENUM;
p.intValAddr = param;
p.maxInt = max;
p.minInt = min;
vector<string> list;
for(int i = min; i <= max; i++){
list.push_back(names[i - min]);
}
p.enumList = list;
p.group = upcomingGroup;
setColorForParam(p, c);
p.intVal = *param = ofClamp(*param, min, max);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Enum Param '" << paramName << "'" ;
}
void ofxRemoteUIServer::shareParam(string paramName, string* param, ofColor c, int nothingUseful ){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_STRING;
p.stringValAddr = param;
p.stringVal = *param;
p.group = upcomingGroup;
setColorForParam(p, c);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing String Param '" << paramName << "'";
}
void ofxRemoteUIServer::shareParam(string paramName, unsigned char* param, ofColor bgColor, int nothingUseful){
RemoteUIParam p;
p.type = REMOTEUI_PARAM_COLOR;
p.redValAddr = param;
p.redVal = param[0];
p.greenVal = param[1];
p.blueVal = param[2];
p.alphaVal = param[3];
p.group = upcomingGroup;
setColorForParam(p, bgColor);
addParamToDB(p, paramName);
if(verbose_) RUI_LOG_NOTICE << "ofxRemoteUIServer Sharing Color Param '" << paramName << "'";
}
void ofxRemoteUIServer::connect(string ipAddress, int port){
avgTimeSinceLastReply = timeSinceLastReply = timeCounter = 0.0f;
waitingForReply = false;
//params.clear();
oscSender.setup(ipAddress, port);
readyToSend = true;
}
void ofxRemoteUIServer::sendLogToClient(const char* format, ...){
if(readyToSend){
// protect from crashes or memory issues
if (strlen(format) >= 1024) {
RUI_LOG_ERROR << "ofxRemoteUIServer log string must be under 1024 chars" << endl;
return;
}
char line[1024];
va_list args;
va_start(args, format);
vsprintf(line, format, args);
sendLogToClient(string(line));
}
}
void ofxRemoteUIServer::sendLogToClient(string message){
if(readyToSend){
ofxOscMessage m;
m.setAddress("LOG_");
m.addStringArg(message);
try{
oscSender.sendMessage(m);
}catch(exception e){
RUI_LOG_ERROR << "exception " << e.what() ;
}
}
}
|
/*
Copyright 2011 Larry Gritz and the other authors and contributors.
All Rights Reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the software's owners nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(This is the Modified BSD License)
*/
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iterator>
#include <vector>
#include <string>
#include <sstream>
#include <utility>
#include <ctype.h>
#include <map>
#include <boost/tokenizer.hpp>
#include <boost/foreach.hpp>
#include <boost/regex.hpp>
#include "OpenImageIO/argparse.h"
#include "OpenImageIO/imageio.h"
#include "OpenImageIO/imagebuf.h"
#include "OpenImageIO/imagebufalgo.h"
#include "OpenImageIO/sysutil.h"
#include "OpenImageIO/filesystem.h"
#include "OpenImageIO/filter.h"
#include "OpenImageIO/color.h"
#include "OpenImageIO/timer.h"
#include "oiiotool.h"
OIIO_NAMESPACE_USING
using namespace OiioTool;
using namespace ImageBufAlgo;
static Oiiotool ot;
Oiiotool::Oiiotool ()
: imagecache(NULL),
return_value (EXIT_SUCCESS),
total_readtime (false /*don't start timer*/),
total_writetime (false /*don't start timer*/),
total_imagecache_readtime (0.0),
enable_function_timing(true)
{
clear_options ();
}
void
Oiiotool::clear_options ()
{
verbose = false;
runstats = false;
noclobber = false;
allsubimages = false;
printinfo = false;
printstats = false;
dumpdata = false;
dumpdata_showempty = true;
hash = false;
updatemode = false;
autoorient = false;
nativeread = false;
threads = 0;
full_command_line.clear ();
printinfo_metamatch.clear ();
printinfo_nometamatch.clear ();
output_dataformat = TypeDesc::UNKNOWN;
output_channelformats.clear ();
output_bitspersample = 0;
output_scanline = false;
output_tilewidth = 0;
output_tileheight = 0;
output_compression = "";
output_quality = -1;
output_planarconfig = "default";
output_adjust_time = false;
output_autocrop = true;
output_autotrim = false;
output_dither = false;
output_force_tiles = false;
metadata_nosoftwareattrib = false;
diff_warnthresh = 1.0e-6f;
diff_warnpercent = 0;
diff_hardwarn = std::numeric_limits<float>::max();
diff_failthresh = 1.0e-6f;
diff_failpercent = 0;
diff_hardfail = std::numeric_limits<float>::max();
m_pending_callback = NULL;
m_pending_argc = 0;
}
std::string
format_resolution (int w, int h, int x, int y)
{
return Strutil::format ("%dx%d%+d%+d", w, h, x, y);
}
std::string
format_resolution (int w, int h, int d, int x, int y, int z)
{
return Strutil::format ("%dx%dx%d%+d%+d%+d", w, h, d, x, y, z);
}
// FIXME -- lots of things we skimped on so far:
// FIXME: check binary ops for compatible image dimensions
// FIXME: handle missing image
// FIXME: reject volume images?
// FIXME: do all ops respect -a (or lack thereof?)
bool
Oiiotool::read (ImageRecRef img)
{
// If the image is already elaborated, take an early out, both to
// save time, but also because we only want to do the format and
// tile adjustments below as images are read in fresh from disk.
if (img->elaborated())
return true;
// Cause the ImageRec to get read. Try to compute how long it took.
// Subtract out ImageCache time, to avoid double-accounting it later.
float pre_ic_time, post_ic_time;
imagecache->getattribute ("stat:fileio_time", pre_ic_time);
total_readtime.start ();
bool ok = img->read (ot.nativeread);
total_readtime.stop ();
imagecache->getattribute ("stat:fileio_time", post_ic_time);
total_imagecache_readtime += post_ic_time - pre_ic_time;
// If this is the first tiled image we have come across, use it to
// set our tile size (unless the user explicitly set a tile size, or
// explicitly instructed scanline output).
const ImageSpec &nspec ((*img)().nativespec());
if (nspec.tile_width && ! output_tilewidth && ! ot.output_scanline) {
output_tilewidth = nspec.tile_width;
output_tileheight = nspec.tile_height;
}
// If we do not yet have an expected output format, set it based on
// this image (presumably the first one read.
if (output_dataformat == TypeDesc::UNKNOWN) {
output_dataformat = nspec.format;
if (! output_bitspersample)
output_bitspersample = nspec.get_int_attribute ("oiio:BitsPerSample");
}
if (! ok) {
error ("read "+img->name(), img->geterror());
}
return ok;
}
bool
Oiiotool::postpone_callback (int required_images, CallbackFunction func,
int argc, const char *argv[])
{
if (((curimg ? 1 : 0) + (int)image_stack.size()) < required_images) {
// Not enough have inputs been specified so far, so put this
// function on the "pending" list.
m_pending_callback = func;
m_pending_argc = argc;
for (int i = 0; i < argc; ++i)
m_pending_argv[i] = ustring(argv[i]).c_str();
return true;
}
return false;
}
void
Oiiotool::process_pending ()
{
// Process any pending command -- this is a case where the
// command line had prefix 'oiiotool --action file1 file2'
// instead of infix 'oiiotool file1 --action file2'.
if (m_pending_callback) {
int argc = m_pending_argc;
const char *argv[4];
for (int i = 0; i < argc; ++i)
argv[i] = m_pending_argv[i];
CallbackFunction callback = m_pending_callback;
m_pending_callback = NULL;
m_pending_argc = 0;
(*callback) (argc, argv);
}
}
void
Oiiotool::error (string_view command, string_view explanation)
{
std::cerr << "oiiotool ERROR: " << command;
if (explanation.length())
std::cerr << " (" << explanation << ")";
std::cerr << "\n";
exit (-1);
}
void
Oiiotool::warning (string_view command, string_view explanation)
{
std::cerr << "oiiotool WARNING: " << command;
if (explanation.length())
std::cerr << " (" << explanation << ")";
std::cerr << "\n";
}
static int
extract_options (std::map<std::string,std::string> &options,
std::string command)
{
// std::cout << "extract_options '" << command << "'\n";
int noptions = 0;
size_t pos;
while ((pos = command.find_first_of(":")) != std::string::npos) {
command = command.substr (pos+1, std::string::npos);
size_t e = command.find_first_of("=");
if (e != std::string::npos) {
std::string name = command.substr(0,e);
std::string value = command.substr(e+1,command.find_first_of(":")-(e+1));
options[name] = value;
++noptions;
// std::cout << "'" << name << "' -> '" << value << "'\n";
}
}
return noptions;
}
static int
set_threads (int argc, const char *argv[])
{
ASSERT (argc == 2);
OIIO::attribute ("threads", atoi(argv[1]));
return 0;
}
static int
set_dumpdata (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.dumpdata = true;
std::map<std::string,std::string> options;
options["empty"] = "1";
extract_options (options, argv[0]);
ot.dumpdata_showempty = Strutil::from_string<int> (options["empty"]);
return 0;
}
static int
set_autopremult (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.imagecache->attribute ("unassociatedalpha", 0);
return 0;
}
static int
unset_autopremult (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.imagecache->attribute ("unassociatedalpha", 1);
return 0;
}
static int
input_file (int argc, const char *argv[])
{
for (int i = 0; i < argc; i++) {
std::map<std::string,ImageRecRef>::const_iterator found;
found = ot.image_labels.find(argv[i]);
if (found != ot.image_labels.end()) {
if (ot.verbose)
std::cout << "Referencing labeled image " << argv[i] << "\n";
ot.push (found->second);
ot.process_pending ();
break;
}
Timer timer (ot.enable_function_timing);
int exists = 1;
if (! ot.imagecache->get_image_info (ustring(argv[i]), 0, 0,
ustring("exists"), TypeDesc::TypeInt, &exists)
|| !exists) {
ot.error ("read", Strutil::format ("Could not open file \"%s\"", argv[i]));
exit (1);
}
if (ot.verbose)
std::cout << "Reading " << argv[i] << "\n";
ot.push (ImageRecRef (new ImageRec (argv[i], ot.imagecache)));
if (ot.printinfo || ot.printstats || ot.dumpdata || ot.hash) {
OiioTool::print_info_options pio;
pio.verbose = ot.verbose;
pio.subimages = ot.allsubimages;
pio.compute_stats = ot.printstats;
pio.dumpdata = ot.dumpdata;
pio.dumpdata_showempty = ot.dumpdata_showempty;
pio.compute_sha1 = ot.hash;
pio.metamatch = ot.printinfo_metamatch;
pio.nometamatch = ot.printinfo_nometamatch;
long long totalsize = 0;
std::string error;
bool ok = OiioTool::print_info (ot, argv[i], pio, totalsize, error);
if (! ok)
ot.error ("read", error);
}
ot.function_times["input"] += timer();
if (ot.autoorient) {
int action_reorient (int argc, const char *argv[]);
const char *argv[] = { "--reorient" };
action_reorient (1, argv);
}
ot.process_pending ();
}
return 0;
}
static int
action_label (int argc, const char *argv[])
{
ot.image_labels[argv[1]] = ot.curimg;
return 0;
}
static void
string_to_dataformat (const std::string &s, TypeDesc &dataformat, int &bits)
{
if (s == "uint8") {
dataformat = TypeDesc::UINT8; bits = 0;
} else if (s == "int8") {
dataformat = TypeDesc::INT8; bits = 0;
} else if (s == "uint10") {
dataformat = TypeDesc::UINT16; bits = 10;
} else if (s == "uint12") {
dataformat = TypeDesc::UINT16; bits = 12;
} else if (s == "uint16") {
dataformat = TypeDesc::UINT16; bits = 0;
} else if (s == "int16") {
dataformat = TypeDesc::INT16; bits = 0;
} else if (s == "uint32") {
dataformat = TypeDesc::UINT32; bits = 0;
} else if (s == "int32") {
dataformat = TypeDesc::INT32; bits = 0;
} else if (s == "half") {
dataformat = TypeDesc::HALF; bits = 0;
} else if (s == "float") {
dataformat = TypeDesc::FLOAT; bits = 0;
} else if (s == "double") {
dataformat = TypeDesc::DOUBLE; bits = 0;
}
}
static void
adjust_output_options (string_view filename,
ImageSpec &spec, const Oiiotool &ot,
bool format_supports_tiles)
{
if (ot.output_dataformat != TypeDesc::UNKNOWN) {
spec.set_format (ot.output_dataformat);
if (ot.output_bitspersample != 0)
spec.attribute ("oiio:BitsPerSample", ot.output_bitspersample);
else
spec.erase_attribute ("oiio:BitsPerSample");
}
if (ot.output_channelformats.size()) {
spec.channelformats.clear ();
spec.channelformats.resize (spec.nchannels, spec.format);
for (int c = 0; c < spec.nchannels; ++c) {
if (c >= (int)spec.channelnames.size())
break;
std::map<std::string,std::string>::const_iterator i = ot.output_channelformats.find (spec.channelnames[c]);
if (i != ot.output_channelformats.end()) {
int bits = 0;
string_to_dataformat (i->second, spec.channelformats[c], bits);
}
}
bool allsame = true;
if (spec.channelnames.size())
for (int c = 1; c < spec.nchannels; ++c)
allsame &= (spec.channelformats[c] == spec.channelformats[0]);
if (allsame) {
spec.format = spec.channelformats[0];
spec.channelformats.clear();
}
} else {
spec.channelformats.clear ();
}
// If we've had tiled input and scanline was not explicitly
// requested, we'll try tiled output.
if (ot.output_tilewidth && !ot.output_scanline && format_supports_tiles) {
spec.tile_width = ot.output_tilewidth;
spec.tile_height = ot.output_tileheight;
spec.tile_depth = 1;
} else {
spec.tile_width = spec.tile_height = spec.tile_depth = 0;
}
if (! ot.output_compression.empty())
spec.attribute ("compression", ot.output_compression);
if (ot.output_quality > 0)
spec.attribute ("CompressionQuality", ot.output_quality);
if (ot.output_planarconfig == "contig" ||
ot.output_planarconfig == "separate")
spec.attribute ("planarconfig", ot.output_planarconfig);
// Append command to image history. Sometimes we may not want to recite the
// entire command line (eg. when we have loaded it up with metadata attributes
// that will make it into the header anyway).
if (! ot.metadata_nosoftwareattrib) {
std::string history = spec.get_string_attribute ("Exif:ImageHistory");
if (! Strutil::iends_with (history, ot.full_command_line)) { // don't add twice
if (history.length() && ! Strutil::iends_with (history, "\n"))
history += std::string("\n");
history += ot.full_command_line;
spec.attribute ("Exif:ImageHistory", history);
}
std::string software = Strutil::format ("OpenImageIO %s : %s",
OIIO_VERSION_STRING, ot.full_command_line);
spec.attribute ("Software", software);
}
if (ot.output_dither) {
int h = (int) Strutil::strhash(filename);
if (!h)
h = 1;
spec.attribute ("oiio:dither", h);
}
// Make sure we kill any special hints that maketx adds and that will
// no longer be valid after whatever oiiotool operations we've done.
spec.erase_attribute ("oiio:SHA-1");
spec.erase_attribute ("oiio:ConstantColor");
spec.erase_attribute ("oiio:AverageColor");
}
static bool
DateTime_to_time_t (const char *datetime, time_t &timet)
{
int year, month, day, hour, min, sec;
int r = sscanf (datetime, "%d:%d:%d %d:%d:%d",
&year, &month, &day, &hour, &min, &sec);
// printf ("%d %d:%d:%d %d:%d:%d\n", r, year, month, day, hour, min, sec);
if (r != 6)
return false;
struct tm tmtime;
time_t now;
Sysutil::get_local_time (&now, &tmtime); // fill in defaults
tmtime.tm_sec = sec;
tmtime.tm_min = min;
tmtime.tm_hour = hour;
tmtime.tm_mday = day;
tmtime.tm_mon = month-1;
tmtime.tm_year = year-1900;
timet = mktime (&tmtime);
return true;
}
static int
output_file (int argc, const char *argv[])
{
ASSERT (argc == 2 && !strcmp(argv[0],"-o"));
Timer timer (ot.enable_function_timing);
ot.total_writetime.start();
std::string filename = argv[1];
if (! ot.curimg.get()) {
ot.warning ("output", filename + " did not have any current image to output.");
return 0;
}
if (ot.noclobber && Filesystem::exists(filename)) {
ot.warning ("output", filename + " already exists, not overwriting.");
return 0;
}
if (ot.verbose)
std::cout << "Writing " << argv[1] << "\n";
ImageOutput *out = ImageOutput::create (filename.c_str());
if (! out) {
ot.error ("output", OIIO::geterror());
return 0;
}
bool supports_displaywindow = out->supports ("displaywindow");
bool supports_negativeorigin = out->supports ("negativeorigin");
bool supports_tiles = out->supports ("tiles") || ot.output_force_tiles;
ot.read ();
ImageRecRef saveimg = ot.curimg;
ImageRecRef ir (ot.curimg);
// Handle --autotrim
if (supports_displaywindow && ot.output_autotrim) {
ROI origroi = get_roi(*ir->spec(0,0));
ROI roi = ImageBufAlgo::nonzero_region ((*ir)(0,0), origroi);
if (roi.npixels() == 0) {
// Special case -- all zero; but doctor to make it 1 zero pixel
roi = origroi;
roi.xend = roi.xbegin+1;
roi.yend = roi.ybegin+1;
roi.zend = roi.zbegin+1;
}
std::string crop = (ir->spec(0,0)->depth == 1)
? format_resolution (roi.width(), roi.height(),
roi.xbegin, roi.ybegin)
: format_resolution (roi.width(), roi.height(), roi.depth(),
roi.xbegin, roi.ybegin, roi.zbegin);
const char *argv[] = { "crop", crop.c_str() };
int action_crop (int argc, const char *argv[]); // forward decl
action_crop (2, argv);
ir = ot.curimg;
}
// Automatically crop/pad if outputting to a format that doesn't
// support display windows, unless autocrop is disabled.
if (! supports_displaywindow && ot.output_autocrop &&
(ir->spec()->x != ir->spec()->full_x ||
ir->spec()->y != ir->spec()->full_y ||
ir->spec()->width != ir->spec()->full_width ||
ir->spec()->height != ir->spec()->full_height)) {
const char *argv[] = { "croptofull" };
int action_croptofull (int argc, const char *argv[]); // forward decl
action_croptofull (1, argv);
ir = ot.curimg;
}
// Automatically crop out the negative areas if outputting to a format
// that doesn't support negative origins.
if (! supports_negativeorigin && ot.output_autocrop &&
(ir->spec()->x < 0 || ir->spec()->y < 0 || ir->spec()->z < 0)) {
ROI roi = get_roi (*ir->spec(0,0));
roi.xbegin = std::max (0, roi.xbegin);
roi.ybegin = std::max (0, roi.ybegin);
roi.zbegin = std::max (0, roi.zbegin);
std::string crop = (ir->spec(0,0)->depth == 1)
? format_resolution (roi.width(), roi.height(),
roi.xbegin, roi.ybegin)
: format_resolution (roi.width(), roi.height(), roi.depth(),
roi.xbegin, roi.ybegin, roi.zbegin);
const char *argv[] = { "crop", crop.c_str() };
int action_crop (int argc, const char *argv[]); // forward decl
action_crop (2, argv);
ir = ot.curimg;
}
// FIXME -- both autotrim and autocrop above neglect to handle
// MIPmaps or subimages with full generality.
std::vector<ImageSpec> subimagespecs (ir->subimages());
for (int s = 0; s < ir->subimages(); ++s) {
ImageSpec spec = *ir->spec(s,0);
adjust_output_options (filename, spec, ot, supports_tiles);
// For deep files, must copy the native deep channelformats
if (spec.deep)
spec.channelformats = (*ir)(s,0).nativespec().channelformats;
subimagespecs[s] = spec;
}
// Do the initial open
ImageOutput::OpenMode mode = ImageOutput::Create;
if (ir->subimages() > 1 && out->supports("multiimage")) {
if (! out->open (filename, ir->subimages(), &subimagespecs[0])) {
ot.error ("output", out->geterror());
return 0;
}
} else {
if (! out->open (filename, subimagespecs[0], mode)) {
ot.error ("output", out->geterror());
return 0;
}
}
// Output all the subimages and MIP levels
for (int s = 0, send = ir->subimages(); s < send; ++s) {
for (int m = 0, mend = ir->miplevels(s); m < mend; ++m) {
ImageSpec spec = *ir->spec(s,m);
adjust_output_options (filename, spec, ot, supports_tiles);
if (s > 0 || m > 0) { // already opened first subimage/level
if (! out->open (filename, spec, mode)) {
ot.error ("output", out->geterror());
return 0;
}
}
if (! (*ir)(s,m).write (out)) {
ot.error ("output", (*ir)(s,m).geterror());
return 0;
}
if (mend > 1) {
if (out->supports("mipmap")) {
mode = ImageOutput::AppendMIPLevel; // for next level
} else if (out->supports("multiimage")) {
mode = ImageOutput::AppendSubimage;
} else {
ot.warning ("output", Strutil::format ("%s does not support MIP-maps for %s",
out->format_name(), filename));
break;
}
}
}
mode = ImageOutput::AppendSubimage; // for next subimage
if (send > 1 && ! out->supports("multiimage")) {
ot.warning ("output", Strutil::format ("%s does not support multiple subimages for %s",
out->format_name(), filename));
break;
}
}
out->close ();
delete out;
if (ot.output_adjust_time) {
std::string metadatatime = ir->spec(0,0)->get_string_attribute ("DateTime");
std::time_t in_time = ir->time();
if (! metadatatime.empty())
DateTime_to_time_t (metadatatime.c_str(), in_time);
Filesystem::last_write_time (filename, in_time);
}
ot.curimg = saveimg;
ot.total_writetime.stop();
ot.function_times["output"] += timer();
return 0;
}
static int
set_dataformat (int argc, const char *argv[])
{
ASSERT (argc == 2);
std::vector<std::string> chans;
Strutil::split (argv[1], chans, ",");
if (chans.size() == 0) {
return 0; // Nothing to do
}
if (chans.size() == 1 && !strchr(chans[0].c_str(),'=')) {
// Of the form: -d uint8 (for example)
// Just one default format designated, apply to all channels
ot.output_dataformat = TypeDesc::UNKNOWN;
ot.output_bitspersample = 0;
string_to_dataformat (chans[0], ot.output_dataformat,
ot.output_bitspersample);
ot.output_channelformats.clear ();
return 0; // we're done
}
// If we make it here, the format designator was of the form
// name0=type0,name1=type1,...
for (size_t i = 0; i < chans.size(); ++i) {
const char *eq = strchr(chans[i].c_str(),'=');
if (eq) {
std::string channame (chans[i], 0, eq - chans[i].c_str());
ot.output_channelformats[channame] = std::string (eq+1);
} else {
ot.error (argv[0], Strutil::format ("Malformed format designator \"%s\"", chans[i]));
}
}
return 0;
}
static int
set_string_attribute (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
set_attribute (ot.curimg, argv[1], TypeDesc::TypeString, argv[2]);
return 0;
}
static int
set_any_attribute (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
set_attribute (ot.curimg, argv[1], TypeDesc(TypeDesc::UNKNOWN), argv[2]);
return 0;
}
static bool
do_erase_attribute (ImageSpec &spec, const std::string &attribname)
{
spec.erase_attribute (attribname);
return true;
}
template<class T>
static bool
do_set_any_attribute (ImageSpec &spec, const std::pair<std::string,T> &x)
{
spec.attribute (x.first, x.second);
return true;
}
bool
Oiiotool::adjust_geometry (string_view command,
int &w, int &h, int &x, int &y, const char *geom,
bool allow_scaling)
{
float scaleX = 1.0f;
float scaleY = 1.0f;
int ww = w, hh = h;
int xx = x, yy = y;
int xmax, ymax;
if (sscanf (geom, "%d,%d,%d,%d", &xx, &yy, &xmax, &ymax) == 4) {
x = xx;
y = yy;
w = std::max (0, xmax-xx+1);
h = std::max (0, ymax-yy+1);
} else if (sscanf (geom, "%dx%d%d%d", &ww, &hh, &xx, &yy) == 4) {
if (ww == 0 && h != 0)
ww = int (hh * float(w)/float(h) + 0.5f);
if (hh == 0 && w != 0)
hh = int (ww * float(h)/float(w) + 0.5f);
w = ww;
h = hh;
x = xx;
y = yy;
} else if (sscanf (geom, "%dx%d", &ww, &hh) == 2) {
if (ww == 0 && h != 0)
ww = int (hh * float(w)/float(h) + 0.5f);
if (hh == 0 && w != 0)
hh = int (ww * float(h)/float(w) + 0.5f);
w = ww;
h = hh;
} else if (allow_scaling && sscanf (geom, "%f%%x%f%%", &scaleX, &scaleY) == 2) {
scaleX = std::max(0.0f, scaleX*0.01f);
scaleY = std::max(0.0f, scaleY*0.01f);
if (scaleX == 0 && scaleY != 0)
scaleX = scaleY;
if (scaleY == 0 && scaleX != 0)
scaleY = scaleX;
w = (int)(w * scaleX + 0.5f);
h = (int)(h * scaleY + 0.5f);
} else if (sscanf (geom, "%d%d", &xx, &yy) == 2) {
x = xx;
y = yy;
} else if (allow_scaling && sscanf (geom, "%f%%", &scaleX) == 1) {
scaleX *= 0.01f;
w = (int)(w * scaleX + 0.5f);
h = (int)(h * scaleX + 0.5f);
} else if (allow_scaling && sscanf (geom, "%f", &scaleX) == 1) {
w = (int)(w * scaleX + 0.5f);
h = (int)(h * scaleX + 0.5f);
} else {
error (command, Strutil::format ("Unrecognized geometry \"%s\"", geom));
return false;
}
// printf ("geom %dx%d, %+d%+d\n", w, h, x, y);
return true;
}
bool
OiioTool::set_attribute (ImageRecRef img, const std::string &attribname,
TypeDesc type, const std::string &value)
{
ot.read (img);
img->metadata_modified (true);
if (! value.length()) {
// If the value is the empty string, clear the attribute
return apply_spec_mod (*img, do_erase_attribute,
attribname, ot.allsubimages);
}
// Does it seem to be an int, or did the caller explicitly request
// that it be set as an int?
char *p = NULL;
int i = strtol (value.c_str(), &p, 10);
while (*p && isspace(*p))
++p;
if ((! *p && type == TypeDesc::UNKNOWN) || type == TypeDesc::INT) {
// int conversion succeeded and accounted for the whole string --
// so set an int attribute.
return apply_spec_mod (*img, do_set_any_attribute<int>,
std::pair<std::string,int>(attribname,i),
ot.allsubimages);
}
// Does it seem to be a float, or did the caller explicitly request
// that it be set as a float?
p = NULL;
float f = (float)strtod (value.c_str(), &p);
while (*p && isspace(*p))
++p;
if ((! *p && type == TypeDesc::UNKNOWN) || type == TypeDesc::FLOAT) {
// float conversion succeeded and accounted for the whole string --
// so set a float attribute.
return apply_spec_mod (*img, do_set_any_attribute<float>,
std::pair<std::string,float>(attribname,f),
ot.allsubimages);
}
// Otherwise, set it as a string attribute
return apply_spec_mod (*img, do_set_any_attribute<std::string>,
std::pair<std::string,std::string>(attribname,value),
ot.allsubimages);
}
static int
set_caption (int argc, const char *argv[])
{
ASSERT (argc == 2);
const char *newargs[3];
newargs[0] = argv[0];
newargs[1] = "ImageDescription";
newargs[2] = argv[1];
return set_string_attribute (3, newargs);
}
static bool
do_set_keyword (ImageSpec &spec, const std::string &keyword)
{
std::string oldkw = spec.get_string_attribute ("Keywords");
std::vector<std::string> oldkwlist;
if (! oldkw.empty())
Strutil::split (oldkw, oldkwlist, ";");
bool dup = false;
BOOST_FOREACH (std::string &ok, oldkwlist) {
ok = Strutil::strip (ok);
dup |= (ok == keyword);
}
if (! dup) {
oldkwlist.push_back (keyword);
spec.attribute ("Keywords", Strutil::join (oldkwlist, "; "));
}
return true;
}
static int
set_keyword (int argc, const char *argv[])
{
ASSERT (argc == 2);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
std::string keyword (argv[1]);
if (keyword.size())
apply_spec_mod (*ot.curimg, do_set_keyword, keyword, ot.allsubimages);
return 0;
}
static int
clear_keywords (int argc, const char *argv[])
{
ASSERT (argc == 1);
const char *newargs[3];
newargs[0] = argv[0];
newargs[1] = "Keywords";
newargs[2] = "";
return set_string_attribute (3, newargs);
}
static int
set_orientation (int argc, const char *argv[])
{
ASSERT (argc == 2);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
return set_attribute (ot.curimg, "Orientation", TypeDesc::INT, argv[1]);
}
static bool
do_rotate_orientation (ImageSpec &spec, string_view cmd)
{
bool rotcw = (cmd == "--orientcw" || cmd == "-orientcw" ||
cmd == "--rotcw" || cmd == "-rotcw");
bool rotccw = (cmd == "--orientccw" || cmd == "-orientccw" ||
cmd == "--rotccw" || cmd == "-rotccw");
bool rot180 = (cmd == "--orient180" || cmd == "-orient180" ||
cmd == "--rot180" || cmd == "-rot180");
int orientation = spec.get_int_attribute ("Orientation", 1);
if (orientation >= 1 && orientation <= 8) {
static int cw[] = { 0, 6, 7, 8, 5, 2, 3, 4, 1 };
if (rotcw || rotccw || rot180)
orientation = cw[orientation];
if (rotccw || rot180)
orientation = cw[orientation];
if (rotccw)
orientation = cw[orientation];
spec.attribute ("Orientation", orientation);
}
return true;
}
static int
rotate_orientation (int argc, const char *argv[])
{
ASSERT (argc == 1);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
apply_spec_mod (*ot.curimg, do_rotate_orientation, argv[0],
ot.allsubimages);
return 0;
}
static int
set_origin (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_origin, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
ImageSpec &spec (*A->spec(0,0));
int x = spec.x, y = spec.y, z = spec.z;
int w = spec.width, h = spec.height, d = spec.depth;
ot.adjust_geometry (argv[0], w, h, x, y, argv[1]);
if (spec.width != w || spec.height != h || spec.depth != d)
ot.warning (argv[0], "can't be used to change the size, only the origin");
if (spec.x != x || spec.y != y) {
ImageBuf &ib = (*A)(0,0);
if (ib.storage() == ImageBuf::IMAGECACHE) {
// If the image is cached, we will totally screw up the IB/IC
// operations if we try to change the origin in place, so in
// that case force a full read to convert to a local buffer,
// which is safe to diddle the origin.
ib.read (0, 0, true /*force*/, spec.format);
}
spec.x = x;
spec.y = y;
spec.z = z;
// That updated the private spec of the ImageRec. In this case
// we really need to update the underlying IB as well.
ImageSpec &ibspec = ib.specmod();
ibspec.x = x;
ibspec.y = y;
ibspec.z = z;
A->metadata_modified (true);
}
ot.function_times["origin"] += timer();
return 0;
}
static int
set_fullsize (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_fullsize, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
ImageSpec &spec (*A->spec(0,0));
int x = spec.full_x, y = spec.full_y;
int w = spec.full_width, h = spec.full_height;
ot.adjust_geometry (argv[0], w, h, x, y, argv[1]);
if (spec.full_x != x || spec.full_y != y ||
spec.full_width != w || spec.full_height != h) {
spec.full_x = x;
spec.full_y = y;
spec.full_width = w;
spec.full_height = h;
A->metadata_modified (true);
}
ot.function_times["fullsize"] += timer();
return 0;
}
static int
set_full_to_pixels (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_full_to_pixels, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
for (int s = 0, send = A->subimages(); s < send; ++s) {
for (int m = 0, mend = A->miplevels(s); m < mend; ++m) {
ImageSpec &spec = *A->spec(s,m);
spec.full_x = spec.x;
spec.full_y = spec.y;
spec.full_z = spec.z;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
// That updated the private spec of the ImageRec. In this case
// we really need to update the underlying IB as well.
ImageSpec &ibspec = (*A)(s,m).specmod();
ibspec.full_x = spec.x;
ibspec.full_y = spec.y;
ibspec.full_z = spec.z;
ibspec.full_width = spec.width;
ibspec.full_height = spec.height;
ibspec.full_depth = spec.depth;
}
}
A->metadata_modified (true);
ot.function_times["fullpixels"] += timer();
return 0;
}
static int
set_colorspace (int argc, const char *argv[])
{
ASSERT (argc == 2);
const char *args[3] = { argv[0], "oiio:ColorSpace", argv[1] };
return set_string_attribute (3, args);
}
static int
action_colorconvert (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (ot.postpone_callback (1, action_colorconvert, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string fromspace = argv[1];
std::string tospace = argv[2];
ot.read ();
bool need_transform = false;
ImageRecRef A = ot.curimg;
ot.read (A);
for (int s = 0, send = A->subimages(); s < send; ++s) {
for (int m = 0, mend = A->miplevels(s); m < mend; ++m) {
const ImageSpec *spec = A->spec(s,m);
need_transform |=
spec->get_string_attribute("oiio:ColorSpace") != tospace;
}
}
if (! need_transform)
return 1; // no need to do anything
ot.pop ();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s) {
for (int m = 0, mend = ot.curimg->miplevels(s); m < mend; ++m) {
bool ok = ImageBufAlgo::colorconvert ((*ot.curimg)(s,m), (*A)(s,m),
fromspace.c_str(), tospace.c_str(), false);
if (! ok)
ot.error (argv[0], (*ot.curimg)(s,m).geterror());
}
}
ot.function_times["colorconvert"] += timer();
return 1;
}
static int
action_tocolorspace (int argc, const char *argv[])
{
// Don't time -- let it get accounted by colorconvert
ASSERT (argc == 2);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
const char *args[3] = { argv[0], "current", argv[1] };
return action_colorconvert (3, args);
}
static int
action_ociolook (int argc, const char *argv[])
{
ASSERT (argc == 2);
if (ot.postpone_callback (1, action_ociolook, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string lookname = argv[1];
std::map<std::string,std::string> options;
options["inverse"] = "0";
options["from"] = "current";
options["to"] = "current";
options["key"] = "";
options["value"] = "";
extract_options (options, argv[0]);
std::string fromspace = options["from"];
std::string tospace = options["to"];
std::string contextkey = options["key"];
std::string contextvalue = options["value"];
bool inverse = Strutil::from_string<int> (options["inverse"]) != 0;
ImageRecRef A = ot.curimg;
ot.read (A);
ot.pop ();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
0, true, true|false));
if (fromspace == "current" || fromspace == "")
fromspace = A->spec(0,0)->get_string_attribute ("oiio:Colorspace", "Linear");
if (tospace == "current" || tospace == "")
tospace = A->spec(0,0)->get_string_attribute ("oiio:Colorspace", "Linear");
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s) {
for (int m = 0, mend = ot.curimg->miplevels(s); m < mend; ++m) {
bool ok = ImageBufAlgo::ociolook (
(*ot.curimg)(s,m), (*A)(s,m),
lookname.c_str(), fromspace.c_str(), tospace.c_str(),
false, inverse,
contextkey.c_str(), contextvalue.c_str());
if (! ok)
ot.error (argv[0], (*ot.curimg)(s,m).geterror());
}
}
ot.function_times["ociolook"] += timer();
return 1;
}
static int
action_ociodisplay (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (ot.postpone_callback (1, action_ociodisplay, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string displayname = argv[1];
std::string viewname = argv[2];
// TODO: this would be useful, but I don't like the syntax
// if (displayname == "")
// displayname = ot.colorconfig.getDefaultDisplayName();
// if (viewname == "")
// viewname = ot.colorconfig.getDefaultViewName();
std::map<std::string,std::string> options;
options["from"] = "current";
options["key"] = "";
options["value"] = "";
extract_options (options, argv[0]);
std::string fromspace = options["from"];
std::string contextkey = options["key"];
std::string contextvalue = options["value"];
bool override_looks = options.find("looks") != options.end();
ImageRecRef A = ot.curimg;
ot.read (A);
ot.pop ();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
0, true, true|false));
if (fromspace == "current" || fromspace == "")
fromspace = A->spec(0,0)->get_string_attribute ("oiio:Colorspace", "Linear");
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s) {
for (int m = 0, mend = ot.curimg->miplevels(s); m < mend; ++m) {
bool ok = ImageBufAlgo::ociodisplay (
(*ot.curimg)(s,m), (*A)(s,m),
displayname.c_str(), viewname.c_str(),
fromspace.c_str(),
override_looks ? options["looks"].c_str() : 0, false,
contextkey.c_str(), contextvalue.c_str());
if (! ok)
ot.error (argv[0], (*ot.curimg)(s,m).geterror());
}
}
ot.function_times["ociodisplay"] += timer();
return 1;
}
static int
action_unpremult (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unpremult, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m)
ImageBufAlgo::unpremult ((*R)(s,m), (*R)(s,m));
ot.function_times["unpremult"] += timer();
return 0;
}
static int
action_premult (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_premult, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m)
ImageBufAlgo::premult ((*R)(s,m), (*R)(s,m));
ot.function_times["premult"] += timer();
return 0;
}
static int
output_tiles (int /*argc*/, const char *argv[])
{
// the ArgParse will have set the tile size, but we need this routine
// to clear the scanline flag
ot.output_scanline = false;
return 0;
}
static int
action_unmip (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unmip, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
bool mipmapped = false;
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s)
mipmapped |= (ot.curimg->miplevels(s) > 1);
if (! mipmapped) {
return 0; // --unmip on an unmipped image is a no-op
}
ImageRecRef newimg (new ImageRec (*ot.curimg, -1, 0, true, true));
ot.curimg = newimg;
ot.function_times["unmip"] += timer();
return 0;
}
static int
set_channelnames (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_channelnames, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.curimg;
ot.read (A);
std::vector<std::string> newchannelnames;
Strutil::split (argv[1], newchannelnames, ",");
for (int s = 0; s < A->subimages(); ++s) {
int miplevels = A->miplevels(s);
for (int m = 0; m < miplevels; ++m) {
ImageSpec *spec = A->spec(s,m);
spec->channelnames.resize (spec->nchannels);
for (int c = 0; c < spec->nchannels; ++c) {
if (c < (int)newchannelnames.size() &&
newchannelnames[c].size()) {
std::string name = newchannelnames[c];
spec->channelnames[c] = name;
if (Strutil::iequals(name,"A") ||
Strutil::iends_with(name,".A") ||
Strutil::iequals(name,"Alpha") ||
Strutil::iends_with(name,".Alpha"))
spec->alpha_channel = c;
if (Strutil::iequals(name,"Z") ||
Strutil::iends_with(name,".Z") ||
Strutil::iequals(name,"Depth") ||
Strutil::iends_with(name,".Depth"))
spec->z_channel = c;
}
}
}
}
ot.function_times["chnames"] += timer();
return 0;
}
// For a given spec (which contains the channel names for an image), and
// a comma separated list of channels (e.g., "B,G,R,A"), compute the
// vector of integer indices for those channels (e.g., {2,1,0,3}).
// A channel may be a literal assignment (e.g., "=0.5"), or a literal
// assignment with channel naming (e.g., "Z=0.5").
// Return true for success, false for failure, including if any of the
// channels were not present in the image. Upon return, channels
// will be the indices of the source image channels to copy (-1 for
// channels that are not filled with source data), values will hold
// the value to fill un-sourced channels (defaulting to zero), and
// newchannelnames will be the name of renamed or non-default-named
// channels (defaulting to "" if no special name is needed).
static bool
decode_channel_set (const ImageSpec &spec, std::string chanlist,
std::vector<std::string> &newchannelnames,
std::vector<int> &channels, std::vector<float> &values)
{
channels.clear ();
while (chanlist.length()) {
// Extract the next channel name
size_t pos = chanlist.find_first_of(",");
std::string onechan (chanlist, 0, pos);
onechan = Strutil::strip (onechan);
if (pos == std::string::npos)
chanlist.clear();
else
chanlist = chanlist.substr (pos+1, std::string::npos);
// Find the index corresponding to that channel
newchannelnames.push_back (std::string());
float value = 0.0f;
int ch = -1;
for (int i = 0; i < spec.nchannels; ++i)
if (spec.channelnames[i] == onechan) { // name of a known channel?
ch = i;
break;
}
if (ch < 0) { // Didn't find a match? Try case-insensitive.
for (int i = 0; i < spec.nchannels; ++i)
if (Strutil::iequals (spec.channelnames[i], onechan)) {
ch = i;
break;
}
}
if (ch < 0 && onechan.length() &&
(isdigit(onechan[0]) || onechan[0] == '-'))
ch = atoi (onechan.c_str()); // numeric channel index
if (ch < 0 && onechan.length()) {
// Look for Either =val or name=val
size_t equal_pos = onechan.find ('=');
if (equal_pos != std::string::npos) {
value = (float) atof (onechan.c_str()+equal_pos+1);
onechan.erase (equal_pos);
newchannelnames.back() = onechan;
}
}
channels.push_back (ch);
values.push_back (value);
}
return true;
}
static int
action_channels (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_channels, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
std::string chanlist = argv[1];
if (chanlist == "RGB") // Fix common synonyms/mistakes
chanlist = "R,G,B";
else if (chanlist == "RGBA")
chanlist = "R,G,B,A";
// Decode the channel set, make the full list of ImageSpec's we'll
// need to describe the new ImageRec with the altered channels.
std::vector<int> allmiplevels;
std::vector<ImageSpec> allspecs;
for (int s = 0, subimages = ot.allsubimages ? A->subimages() : 1;
s < subimages; ++s) {
std::vector<std::string> newchannelnames;
std::vector<int> channels;
std::vector<float> values;
bool ok = decode_channel_set (*A->spec(s,0), chanlist,
newchannelnames, channels, values);
if (! ok) {
ot.error (argv[0], Strutil::format("Invalid or unknown channel selection \"%s\"", chanlist));
ot.push (A);
return 0;
}
int miplevels = ot.allsubimages ? A->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
for (int m = 0; m < miplevels; ++m) {
ImageSpec spec = *A->spec(s,m);
spec.nchannels = (int)newchannelnames.size();
spec.channelformats.clear();
spec.default_channel_names ();
allspecs.push_back (spec);
}
}
// Create the replacement ImageRec
ImageRecRef R (new ImageRec(A->name(), (int)allmiplevels.size(),
&allmiplevels[0], &allspecs[0]));
ot.push (R);
// Subimage by subimage, MIP level by MIP level, copy/shuffle the
// channels individually from the source image into the result.
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
std::vector<std::string> newchannelnames;
std::vector<int> channels;
std::vector<float> values;
decode_channel_set (*A->spec(s,0), chanlist, newchannelnames,
channels, values);
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
// Shuffle the indexed/named channels
bool ok = ImageBufAlgo::channels ((*R)(s,m), (*A)(s,m),
(int)channels.size(), &channels[0],
&values[0], &newchannelnames[0], false);
if (! ok)
ot.error ("channels", (*R)(s,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(s,m);
}
}
ot.function_times["channels"] += timer();
return 0;
}
static int
action_chappend (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_chappend, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
std::vector<int> allmiplevels;
for (int s = 0, subimages = ot.allsubimages ? A->subimages() : 1;
s < subimages; ++s) {
int miplevels = ot.allsubimages ? A->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
}
// Create the replacement ImageRec
ImageRecRef R (new ImageRec(A->name(), (int)allmiplevels.size(),
&allmiplevels[0]));
ot.push (R);
// Subimage by subimage, MIP level by MIP level, channel_append the
// two images.
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
// Shuffle the indexed/named channels
bool ok = ImageBufAlgo::channel_append ((*R)(s,m), (*A)(s,m), (*B)(s,m));
if (! ok)
ot.error ("chappend", (*R)(s,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(s,m);
}
}
ot.function_times["chappend"] += timer();
return 0;
}
static int
action_selectmip (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_selectmip, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
bool mipmapped = false;
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s)
mipmapped |= (ot.curimg->miplevels(s) > 1);
if (! mipmapped) {
return 0; // --selectmip on an unmipped image is a no-op
}
ImageRecRef newimg (new ImageRec (*ot.curimg, -1, atoi(argv[1]), true, true));
ot.curimg = newimg;
ot.function_times["selectmip"] += timer();
return 0;
}
static int
action_select_subimage (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_select_subimage, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
int subimage = atoi(argv[1]);
if (subimage < 0 || subimage >= ot.curimg->subimages()) {
ot.error ("-subimage",
Strutil::format ("Invalid -subimage (%d): %s has %d subimage%s",
subimage, ot.curimg->name(), ot.curimg->subimages(),
ot.curimg->subimages() == 1 ? "" : "s"));
return 0;
}
if (ot.curimg->subimages() == 1)
return 0; // --subimage on a single-image file is a no-op
ImageRecRef A = ot.pop();
ot.push (new ImageRec (*A, subimage));
ot.function_times["subimage"] += timer();
return 0;
}
static int
action_subimage_append (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_subimage_append, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
// Find the MIP levels in all the subimages of both A and B
std::vector<int> allmiplevels;
for (int s = 0; s < A->subimages(); ++s) {
int miplevels = ot.allsubimages ? A->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
}
for (int s = 0; s < B->subimages(); ++s) {
int miplevels = ot.allsubimages ? B->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
}
// Create the replacement ImageRec
ImageRecRef R (new ImageRec(A->name(), (int)allmiplevels.size(),
&allmiplevels[0]));
ot.push (R);
// Subimage by subimage, MIP level by MIP level, copy
int sub = 0;
for (int s = 0; s < A->subimages(); ++s, ++sub) {
for (int m = 0; m < A->miplevels(s); ++m) {
bool ok = (*R)(sub,m).copy ((*A)(s,m));
if (! ok)
ot.error ("siappend", (*R)(sub,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(sub,m);
}
}
for (int s = 0; s < B->subimages(); ++s, ++sub) {
for (int m = 0; m < B->miplevels(s); ++m) {
bool ok = (*R)(sub,m).copy ((*B)(s,m));
if (! ok)
ot.error ("siappend", (*R)(sub,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(sub,m);
}
}
ot.function_times["siappend"] += timer();
return 0;
}
static int
action_colorcount (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_colorcount, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageBuf &Aib ((*ot.curimg)(0,0));
int nchannels = Aib.nchannels();
// We assume ';' to split, but for the sake of some command shells,
// that use ';' as a command separator, also accept ":".
std::vector<float> colorvalues;
std::vector<std::string> colorstrings;
if (strchr (argv[1], ':'))
Strutil::split (argv[1], colorstrings, ":");
else
Strutil::split (argv[1], colorstrings, ";");
int ncolors = (int) colorstrings.size();
for (int col = 0; col < ncolors; ++col) {
std::vector<float> color (nchannels, 0.0f);
Strutil::extract_from_list_string (color, colorstrings[col], ",");
for (int c = 0; c < nchannels; ++c)
colorvalues.push_back (c < (int)color.size() ? color[c] : 0.0f);
}
std::vector<float> eps (nchannels, 0.001f);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
Strutil::extract_from_list_string (eps, options["eps"]);
imagesize_t *count = ALLOCA (imagesize_t, ncolors);
bool ok = ImageBufAlgo::color_count ((*ot.curimg)(0,0), count,
ncolors, &colorvalues[0], &eps[0]);
if (ok) {
for (int col = 0; col < ncolors; ++col)
std::cout << Strutil::format("%8d %s\n", count[col], colorstrings[col]);
} else {
ot.error ("colorcount", (*ot.curimg)(0,0).geterror());
}
ot.function_times["colorcount"] += timer();
return 0;
}
static int
action_rangecheck (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rangecheck, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageBuf &Aib ((*ot.curimg)(0,0));
int nchannels = Aib.nchannels();
std::vector<float> low(nchannels,0.0f), high(nchannels,1.0f);
Strutil::extract_from_list_string (low, argv[1], ",");
Strutil::extract_from_list_string (high, argv[2], ",");
imagesize_t lowcount = 0, highcount = 0, inrangecount = 0;
bool ok = ImageBufAlgo::color_range_check ((*ot.curimg)(0,0), &lowcount,
&highcount, &inrangecount,
&low[0], &high[0]);
if (ok) {
std::cout << Strutil::format("%8d < %s\n", lowcount, argv[1]);
std::cout << Strutil::format("%8d > %s\n", highcount, argv[2]);
std::cout << Strutil::format("%8d within range\n", inrangecount);
} else {
ot.error ("rangecheck", (*ot.curimg)(0,0).geterror());
}
ot.function_times["rangecheck"] += timer();
return 0;
}
static int
action_diff (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_diff, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int ret = do_action_diff (*ot.image_stack.back(), *ot.curimg, ot);
if (ret != DiffErrOK && ret != DiffErrWarn)
ot.return_value = EXIT_FAILURE;
if (ret != DiffErrOK && ret != DiffErrWarn && ret != DiffErrFail)
ot.error ("Error doing --diff");
ot.function_times["diff"] += timer();
return 0;
}
static int
action_pdiff (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_pdiff, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int ret = do_action_diff (*ot.image_stack.back(), *ot.curimg, ot, 1);
if (ret != DiffErrOK && ret != DiffErrWarn)
ot.return_value = EXIT_FAILURE;
if (ret != DiffErrOK && ret != DiffErrWarn && ret != DiffErrFail)
ot.error ("Error doing %s", argv[0]);
ot.function_times["pdiff"] += timer();
return 0;
}
static int
action_add (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_add, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
ImageRecRef R (new ImageRec (*A, *B, ot.allsubimages ? -1 : 0,
ImageRec::WinMergeUnion,
ImageRec::WinMergeUnion, TypeDesc::FLOAT));
ot.push (R);
int subimages = R->subimages();
for (int s = 0; s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
const ImageBuf &Bib ((*B)(s));
bool ok = ImageBufAlgo::add (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
ot.function_times["add"] += timer();
return 0;
}
static int
action_sub (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_sub, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
ImageRecRef R (new ImageRec (*A, *B, ot.allsubimages ? -1 : 0,
ImageRec::WinMergeUnion,
ImageRec::WinMergeUnion, TypeDesc::FLOAT));
ot.push (R);
int subimages = R->subimages();
for (int s = 0; s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
const ImageBuf &Bib ((*B)(s));
bool ok = ImageBufAlgo::sub (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
ot.function_times["sub"] += timer();
return 0;
}
static int
action_mul (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_mul, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
ImageRecRef R (new ImageRec (*A, *B, ot.allsubimages ? -1 : 0,
ImageRec::WinMergeUnion,
ImageRec::WinMergeUnion, TypeDesc::FLOAT));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
const ImageBuf &Bib ((*B)(s));
bool ok = ImageBufAlgo::mul (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
ot.function_times["mul"] += timer();
return 0;
}
static int
action_abs (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_abs, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int miplevels = ot.curimg->miplevels(s);
for (int m = 0; m < miplevels; ++m) {
const ImageBuf &Aib ((*A)(s,m));
ImageBuf &Rib ((*ot.curimg)(s,m));
ImageBuf::ConstIterator<float> a (Aib);
ImageBuf::Iterator<float> r (Rib);
int nchans = Rib.nchannels();
for ( ; ! r.done(); ++r) {
a.pos (r.x(), r.y());
for (int c = 0; c < nchans; ++c)
r[c] = fabsf(a[c]);
}
}
}
ot.function_times["abs"] += timer();
return 0;
}
static int
action_cmul (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cmul, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::vector<std::string> scalestrings;
Strutil::split (std::string(argv[1]), scalestrings, ",");
if (scalestrings.size() < 1)
return 0; // Implicit multiplication by 1 if we can't figure it out
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
std::vector<float> scale;
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int nchans = R->spec(s,0)->nchannels;
scale.clear ();
scale.resize (nchans, (float) atof(scalestrings[0].c_str()));
if (scalestrings.size() > 1) {
for (int c = 0; c < nchans; ++c) {
if (c < (int)scalestrings.size())
scale[c] = (float) atof(scalestrings[c].c_str());
else
scale[c] = 1.0f;
}
}
for (int m = 0, miplevels = ot.curimg->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::mul ((*R)(s,m), (*R)(s,m), &scale[0]);
if (! ok)
ot.error ("cmul", (*R)(s,m).geterror());
}
}
ot.function_times["cmul"] += timer();
return 0;
}
static int
action_cadd (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cadd, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::vector<std::string> addstrings;
Strutil::split (std::string(argv[1]), addstrings, ",");
if (addstrings.size() < 1)
return 0; // Implicit addition by 0 if we can't figure it out
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
std::vector<float> val;
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int nchans = R->spec(s,0)->nchannels;
val.clear ();
val.resize (nchans, (float) atof(addstrings[0].c_str()));
if (addstrings.size() > 1) {
for (int c = 0; c < nchans; ++c) {
if (c < (int)addstrings.size())
val[c] = (float) atof(addstrings[c].c_str());
else
val[c] = 0.0f;
}
}
for (int m = 0, miplevels = ot.curimg->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::add ((*R)(s,m), (*R)(s,m), &val[0]);
if (! ok)
ot.error ("cadd", (*R)(s,m).geterror());
}
}
ot.function_times["cadd"] += timer();
return 0;
}
static int
action_cpow (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cpow, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::vector<std::string> scalestrings;
Strutil::split (std::string(argv[1]), scalestrings, ",");
if (scalestrings.size() < 1)
return 0; // Implicit multiplication by 1 if we can't figure it out
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
std::vector<float> scale;
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int nchans = R->spec(s,0)->nchannels;
scale.clear ();
scale.resize (nchans, (float) atof(scalestrings[0].c_str()));
if (scalestrings.size() > 1) {
for (int c = 0; c < nchans; ++c) {
if (c < (int)scalestrings.size())
scale[c] = (float) atof(scalestrings[c].c_str());
else
scale[c] = 1.0f;
}
}
for (int m = 0, miplevels = ot.curimg->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::pow ((*R)(s,m), (*R)(s,m), &scale[0]);
if (! ok)
ot.error ("cpow", (*R)(s,m).geterror());
}
}
ot.function_times["cpow"] += timer();
return 0;
}
static int
action_chsum (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_chsum, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("chsum", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
std::vector<float> weight ((*A)(s).nchannels(), 1.0f);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
Strutil::extract_from_list_string (weight, options["weight"]);
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
bool ok = ImageBufAlgo::channel_sum (Rib, Aib, &weight[0]);
if (! ok)
ot.error ("chsum", Rib.geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["chsum"] += timer();
return 0;
}
static int
action_flip (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_flip, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("flip", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::flip ((*R)(s), (*A)(s));
if (! ok)
ot.error ("flip", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["flip"] += timer();
return 0;
}
static int
action_flop (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_flop, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("flop", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::flop ((*R)(s), (*A)(s));
if (! ok)
ot.error ("flop", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["flop"] += timer();
return 0;
}
static int
action_rotate180 (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate180, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("rotate180", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::rotate180 ((*R)(s), (*A)(s));
if (! ok)
ot.error ("rotate180", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate180"] += timer();
return 0;
}
static int
action_rotate90 (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate90, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("rotate90", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::rotate90 ((*R)(s), (*A)(s));
if (! ok)
ot.error ("rotate90", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate90"] += timer();
return 0;
}
static int
action_rotate270 (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate270, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("rotate270", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::rotate270 ((*R)(s), (*A)(s));
if (! ok)
ot.error ("rotate270", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate270"] += timer();
return 0;
}
int
action_reorient (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_reorient, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Make sure time in the rotate functions is charged to reorient
bool old_enable_function_timing = ot.enable_function_timing;
ot.enable_function_timing = false;
ImageRecRef A = ot.pop();
ot.read (A);
// See if any subimages need to be reoriented
bool needs_reorient = false;
for (int s = 0, subimages = A->subimages(); s < subimages; ++s) {
int orientation = (*A)(s).orientation();
needs_reorient |= (orientation != 1);
}
if (needs_reorient) {
ImageRecRef R (new ImageRec ("reorient", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBufAlgo::reorient ((*R)(s), (*A)(s));
R->update_spec_from_imagebuf (s);
}
} else {
// No subimages need modification, just leave the whole thing in
// place.
ot.push (A);
}
ot.function_times["reorient"] += timer();
ot.enable_function_timing = old_enable_function_timing;
return 0;
}
static int
action_transpose (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_transpose, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("transpose",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::transpose ((*R)(s), (*A)(s));
if (! ok)
ot.error ("transpose", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["transpose"] += timer();
return 0;
}
static int
action_rotate (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string filtername = options["filter"];
bool recompute_roi = Strutil::from_string<int>(options["recompute_roi"]);
bool center_supplied = false;
std::string center = options["center"];
float center_x = 0.0f, center_y = 0.0f;
if (center.size()) {
string_view s (center);
if (Strutil::parse_float (s, center_x) &&
Strutil::parse_char (s, ',') &&
Strutil::parse_float (s, center_y)) {
center_supplied = true;
}
}
float angle = Strutil::from_string<float> (argv[1]);
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("rotate",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
float cx, cy;
if (center_supplied) {
cx = center_x;
cy = center_y;
} else {
ROI src_roi_full = (*A)(s).roi_full();
cx = 0.5f * (src_roi_full.xbegin + src_roi_full.xend);
cy = 0.5f * (src_roi_full.ybegin + src_roi_full.yend);
}
bool ok = ImageBufAlgo::rotate ((*R)(s), (*A)(s),
angle*float(M_PI/180.0), cx, cy,
filtername, 0.0f, recompute_roi);
if (! ok)
ot.error ("rotate", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate"] += timer();
return 0;
}
static int
action_warp (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_warp, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string filtername = options["filter"];
bool recompute_roi = Strutil::from_string<int>(options["recompute_roi"]);
std::vector<float> M (9);
if (Strutil::extract_from_list_string (M, argv[1]) != 9) {
ot.error ("warp", "expected 9 comma-separatd floats to form a 3x3 matrix");
return 0;
}
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("warp",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::warp ((*R)(s), (*A)(s),
*(Imath::M33f *)&M[0],
filtername, 0.0f,
recompute_roi, ImageBuf::WrapDefault);
if (! ok)
ot.error ("warp", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["warp"] += timer();
return 0;
}
static int
action_cshift (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cshift, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int x = 0, y = 0, z = 0;
if (sscanf (argv[1], "%d%d%d", &x, &y, &z) < 2) {
ot.error ("cshift", Strutil::format ("Invalid shift offset '%s'", argv[1]));
return 0;
}
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("cshift",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::circular_shift ((*R)(s), (*A)(s), x, y, z);
if (! ok)
ot.error ("cshift", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["cshift"] += timer();
return 0;
}
static int
action_pop (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.pop ();
return 0;
}
static int
action_dup (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.push (ot.curimg);
return 0;
}
static int
action_swap (int argc, const char *argv[])
{
ASSERT (argc == 1);
if (ot.image_stack.size() < 1) {
ot.error (argv[0], "requires at least two loaded images");
return 0;
}
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.push (B);
ot.push (A);
return 0;
}
static int
action_create (int argc, const char *argv[])
{
ASSERT (argc == 3);
Timer timer (ot.enable_function_timing);
int nchans = atoi (argv[2]);
if (nchans < 1 || nchans > 1024) {
ot.warning (argv[0], Strutil::format ("Invalid number of channels: %d", nchans));
nchans = 3;
}
ImageSpec spec (64, 64, nchans, TypeDesc::FLOAT);
ot.adjust_geometry (argv[0], spec.width, spec.height, spec.x, spec.y, argv[1]);
spec.full_x = spec.x;
spec.full_y = spec.y;
spec.full_z = spec.z;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
ImageRecRef img (new ImageRec ("new", spec, ot.imagecache));
bool ok = ImageBufAlgo::zero ((*img)());
if (! ok)
ot.error (argv[0], (*img)().geterror());
if (ot.curimg)
ot.image_stack.push_back (ot.curimg);
ot.curimg = img;
ot.function_times["create"] += timer();
return 0;
}
static int
action_pattern (int argc, const char *argv[])
{
ASSERT (argc == 4);
Timer timer (ot.enable_function_timing);
int nchans = atoi (argv[3]);
if (nchans < 1 || nchans > 1024) {
ot.warning (argv[0], Strutil::format ("Invalid number of channels: %d", nchans));
nchans = 3;
}
ImageSpec spec (64, 64, nchans, TypeDesc::FLOAT);
ot.adjust_geometry (argv[0], spec.width, spec.height, spec.x, spec.y, argv[2]);
spec.full_x = spec.x;
spec.full_y = spec.y;
spec.full_z = spec.z;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
ImageRecRef img (new ImageRec ("new", spec, ot.imagecache));
ImageBuf &ib ((*img)());
std::string pattern = argv[1];
if (Strutil::iequals(pattern,"black")) {
bool ok = ImageBufAlgo::zero (ib);
if (! ok)
ot.error (argv[0], ib.geterror());
} else if (Strutil::istarts_with(pattern,"constant")) {
std::vector<float> fill (nchans, 1.0f);
std::map<std::string,std::string> options;
extract_options (options, pattern);
Strutil::extract_from_list_string (fill, options["color"]);
bool ok = ImageBufAlgo::fill (ib, &fill[0]);
if (! ok)
ot.error (argv[0], ib.geterror());
} else if (Strutil::istarts_with(pattern,"checker")) {
std::map<std::string,std::string> options;
options["width"] = "8";
options["height"] = "8";
options["depth"] = "8";
extract_options (options, pattern);
int width = Strutil::from_string<int> (options["width"]);
int height = Strutil::from_string<int> (options["height"]);
int depth = Strutil::from_string<int> (options["depth"]);
std::vector<float> color1 (nchans, 0.0f);
std::vector<float> color2 (nchans, 1.0f);
Strutil::extract_from_list_string (color1, options["color1"]);
Strutil::extract_from_list_string (color2, options["color2"]);
bool ok = ImageBufAlgo::checker (ib, width, height, depth,
&color1[0], &color2[0], 0, 0, 0);
if (! ok)
ot.error (argv[0], ib.geterror());
} else {
bool ok = ImageBufAlgo::zero (ib);
if (! ok)
ot.error (argv[0], ib.geterror());
}
ot.push (img);
ot.function_times["pattern"] += timer();
return 0;
}
static int
action_kernel (int argc, const char *argv[])
{
ASSERT (argc == 3);
Timer timer (ot.enable_function_timing);
int nchans = 1;
if (nchans < 1 || nchans > 1024) {
ot.warning (argv[0], Strutil::format ("Invalid number of channels: %d", nchans));
nchans = 3;
}
float w = 1.0f, h = 1.0f;
if (sscanf (argv[2], "%fx%f", &w, &h) != 2)
ot.error ("kernel", Strutil::format ("Unknown size %s", argv[2]));
ImageSpec spec (1, 1, nchans, TypeDesc::FLOAT);
ImageRecRef img (new ImageRec ("kernel", spec, ot.imagecache));
ImageBuf &ib ((*img)());
int ok = ImageBufAlgo::make_kernel (ib, argv[1], w, h);
if (! ok)
ot.error (argv[0], ib.geterror());
img->update_spec_from_imagebuf (0, 0);
ot.push (img);
ot.function_times["kernel"] += timer();
return 0;
}
static int
action_capture (int argc, const char *argv[])
{
ASSERT (argc == 1);
Timer timer (ot.enable_function_timing);
int camera = 0;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(cmd,"camera="))
camera = atoi(cmd.c_str()+7);
}
ImageBuf ib;
bool ok = ImageBufAlgo::capture_image (ib, camera, TypeDesc::FLOAT);
if (! ok)
ot.error (argv[0], ib.geterror());
ImageRecRef img (new ImageRec ("capture", ib.spec(), ot.imagecache));
(*img)().copy (ib);
ot.push (img);
ot.function_times["capture"] += timer();
return 0;
}
int
action_crop (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_crop, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1]);
if (newspec.width != Aspec.width || newspec.height != Aspec.height) {
// resolution changed -- we need to do a full crop
ot.pop();
ot.push (new ImageRec (A->name(), newspec, ot.imagecache));
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*ot.curimg)(0,0));
bool ok = ImageBufAlgo::crop (Rib, Aib, get_roi(newspec));
if (! ok)
ot.error (argv[0], Rib.geterror());
} else if (newspec.x != Aspec.x || newspec.y != Aspec.y) {
// only offset changed; don't copy the image or crop, simply
// adjust the origins.
Aspec.x = newspec.x;
Aspec.y = newspec.y;
A->metadata_modified (true);
}
ot.function_times["crop"] += timer();
return 0;
}
int
action_croptofull (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_croptofull, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
const ImageSpec &Aspec (*A->spec(0,0));
// Implement by calling action_crop with a geometry specifier built
// from the current full image size.
std::string size = format_resolution (Aspec.full_width, Aspec.full_height,
Aspec.full_x, Aspec.full_y);
const char *newargv[2] = { "crop", size.c_str() };
bool old_enable_function_timing = ot.enable_function_timing;
ot.enable_function_timing = false;
int result = action_crop (2, newargv);
ot.function_times["croptofull"] += timer();
ot.enable_function_timing = old_enable_function_timing;
return result;
}
int
action_cut (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cut, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1]);
ImageRecRef R (new ImageRec (A->name(), newspec, ot.imagecache));
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*R)(0,0));
ImageBufAlgo::cut (Rib, Aib, get_roi(newspec));
ImageSpec &spec (*R->spec(0,0));
set_roi (spec, Rib.roi());
set_roi_full (spec, Rib.roi());
A->metadata_modified (true);
ot.push (R);
ot.function_times["cut"] += timer();
return 0;
}
static int
action_resample (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_resample, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
const ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1], true);
if (newspec.width == Aspec.width && newspec.height == Aspec.height) {
ot.push (A); // Restore the original image
return 0; // nothing to do
}
// Shrink-wrap full to match actual pixels; I'm not sure what else
// is appropriate, need to think it over.
newspec.full_x = newspec.x;
newspec.full_y = newspec.y;
newspec.full_width = newspec.width;
newspec.full_height = newspec.height;
ot.push (new ImageRec (A->name(), newspec, ot.imagecache));
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*ot.curimg)(0,0));
bool ok = ImageBufAlgo::resample (Rib, Aib);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["resample"] += timer();
return 0;
}
static int
action_resize (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_resize, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string filtername;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (! strncmp (cmd.c_str(), "filter=", 7)) {
filtername = cmd.substr (7, std::string::npos);
}
}
ot.read ();
ImageRecRef A = ot.pop();
const ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1], true);
if (newspec.width == Aspec.width && newspec.height == Aspec.height) {
ot.push (A); // Restore the original image
return 0; // nothing to do
}
// Shrink-wrap full to match actual pixels; I'm not sure what else
// is appropriate, need to think it over.
newspec.full_x = newspec.x;
newspec.full_y = newspec.y;
newspec.full_width = newspec.width;
newspec.full_height = newspec.height;
ot.push (new ImageRec (A->name(), newspec, ot.imagecache));
if (ot.verbose) {
std::cout << "Resizing " << Aspec.width << "x" << Aspec.height
<< " to " << newspec.width << "x" << newspec.height
<< " using "
<< (filtername.size() ? filtername.c_str() : "default")
<< " filter\n";
}
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*ot.curimg)(0,0));
bool ok = ImageBufAlgo::resize (Rib, Aib, filtername, 0.0f, get_roi(Rib.spec()));
ot.function_times["resize"] += timer();
if (! ok)
ot.error (argv[0], Rib.geterror());
return 0;
}
static int
action_fit (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fit, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
bool old_enable_function_timing = ot.enable_function_timing;
ot.enable_function_timing = false;
// Examine the top of stack
ImageRecRef A = ot.top();
ot.read ();
const ImageSpec *Aspec = A->spec(0,0);
// Parse the user request for resolution to fit
int fit_full_width = Aspec->full_width;
int fit_full_height = Aspec->full_height;
int fit_full_x = Aspec->full_x;
int fit_full_y = Aspec->full_y;
ot.adjust_geometry (argv[0], fit_full_width, fit_full_height,
fit_full_x, fit_full_y, argv[1], false);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string padopt = options["pad"];
bool pad = padopt.size() && atoi(padopt.c_str());
std::string filtername = options["filter"];
// Compute scaling factors and use action_resize to do the heavy lifting
float oldaspect = float(Aspec->full_width) / Aspec->full_height;
float newaspect = float(fit_full_width) / fit_full_height;
int resize_full_width = fit_full_width;
int resize_full_height = fit_full_height;
int xoffset = 0, yoffset = 0;
if (newaspect >= oldaspect) { // same or wider than original
resize_full_width = int(resize_full_height * oldaspect + 0.5f);
xoffset = (fit_full_width - resize_full_width) / 2;
} else { // narrower than original
resize_full_height = int(resize_full_width / oldaspect + 0.5f);
yoffset = (fit_full_height - resize_full_height) / 2;
}
if (ot.verbose) {
std::cout << "Fitting "
<< format_resolution(Aspec->full_width, Aspec->full_height,
Aspec->full_x, Aspec->full_y)
<< " into "
<< format_resolution(fit_full_width, fit_full_height,
fit_full_x, fit_full_y)
<< "\n";
std::cout << " Resizing to "
<< format_resolution(resize_full_width, resize_full_height,
fit_full_x, fit_full_y) << "\n";
}
if (resize_full_width != Aspec->full_width ||
resize_full_height != Aspec->full_height ||
fit_full_x != Aspec->full_x || fit_full_y != Aspec->full_y) {
std::string resize = format_resolution (resize_full_width,
resize_full_height,
0, 0);
std::string command = "resize";
if (filtername.size())
command += Strutil::format (":filter=%s", filtername);
const char *newargv[2] = { command.c_str(), resize.c_str() };
action_resize (2, newargv);
A = ot.top ();
Aspec = A->spec(0,0);
A->spec(0,0)->full_width = (*A)(0,0).specmod().full_width = fit_full_width;
A->spec(0,0)->full_height = (*A)(0,0).specmod().full_height = fit_full_height;
A->spec(0,0)->full_x = (*A)(0,0).specmod().full_x = fit_full_x;
A->spec(0,0)->full_y = (*A)(0,0).specmod().full_y = fit_full_y;
A->spec(0,0)->x = (*A)(0,0).specmod().x = xoffset;
A->spec(0,0)->y = (*A)(0,0).specmod().y = yoffset;
// Now A,Aspec are for the NEW resized top of stack
}
if (pad && (fit_full_width != Aspec->width ||
fit_full_height != Aspec->height)) {
// Needs padding
const char *argv[] = { "croptofull" };
action_croptofull (1, argv);
}
ot.function_times["fit"] += timer();
ot.enable_function_timing = old_enable_function_timing;
return 0;
}
static int
action_convolve (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_convolve, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef K = ot.pop(); // kernel
ImageRecRef A = ot.pop();
A->read();
K->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::convolve (Rib, (*A)(s), (*K)(0));
if (! ok)
ot.error ("convolve", Rib.geterror());
}
ot.function_times["convolve"] += timer();
return 0;
}
static int
action_blur (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_blur, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
options["kernel"] = "gaussian";
extract_options (options, argv[0]);
std::string kernopt = options["kernel"];
float w = 1.0f, h = 1.0f;
if (sscanf (argv[1], "%fx%f", &w, &h) != 2)
ot.error ("blur", Strutil::format ("Unknown size %s", argv[1]));
ImageBuf Kernel ("kernel");
if (! ImageBufAlgo::make_kernel (Kernel, kernopt.c_str(), w, h))
ot.error ("blur", Kernel.geterror());
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::convolve (Rib, (*A)(s), Kernel);
if (! ok)
ot.error ("blur", Rib.geterror());
}
ot.function_times["blur"] += timer();
return 0;
}
static int
action_median (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_median, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int w = 3, h = 3;
if (sscanf (argv[1], "%dx%d", &w, &h) != 2)
ot.error ("median", Strutil::format ("Unknown size %s", argv[1]));
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::median_filter (Rib, (*A)(s), w, h);
if (! ok)
ot.error ("median", Rib.geterror());
}
ot.function_times["median"] += timer();
return 0;
}
static int
action_unsharp (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unsharp, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
options["kernel"] = "gaussian";
options["width"] = "3";
options["contrast"] = "1";
options["threshold"] = "0";
extract_options (options, argv[0]);
std::string kernel = options["kernel"];
float width = Strutil::from_string<float> (options["width"]);
float contrast = Strutil::from_string<float> (options["contrast"]);
float threshold = Strutil::from_string<float> (options["threshold"]);
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::unsharp_mask (Rib, (*A)(s), kernel.c_str(),
width, contrast, threshold);
if (! ok)
ot.error ("unsharp", Rib.geterror());
}
ot.function_times["unsharp"] += timer();
return 0;
}
static int
action_fft (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fft, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec ("fft", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::fft (Rib, (*A)(s));
R->update_spec_from_imagebuf (s);
if (! ok)
ot.error ("fft", Rib.geterror());
}
ot.function_times["fft"] += timer();
return 0;
}
static int
action_ifft (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_ifft, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec ("ifft", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::ifft (Rib, (*A)(s));
R->update_spec_from_imagebuf (s);
if (! ok)
ot.error ("ifft", Rib.geterror());
}
ot.function_times["ifft"] += timer();
return 0;
}
static int
action_polar (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_polar, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::complex_to_polar ((*R)(s,m), (*A)(s,m));
if (! ok)
ot.error ("polar", (*R)(s,m).geterror());
}
ot.function_times["polar"] += timer();
return 0;
}
static int
action_unpolar (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unpolar, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::polar_to_complex ((*R)(s,m), (*A)(s,m));
if (! ok)
ot.error ("unpolar", (*R)(s,m).geterror());
}
ot.function_times["unpolar"] += timer();
return 0;
}
int
action_fixnan (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fixnan, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
NonFiniteFixMode mode = NONFINITE_BOX3;
if (!strcmp(argv[1], "black"))
mode = NONFINITE_BLACK;
else if (!strcmp(argv[1], "box3"))
mode = NONFINITE_BOX3;
else {
ot.warning (argv[0], Strutil::format ("\"%s\" not recognized. Valid choices: black, box3.", argv[1]));
}
ot.read ();
ImageRecRef A = ot.pop();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int miplevels = ot.curimg->miplevels(s);
for (int m = 0; m < miplevels; ++m) {
const ImageBuf &Aib ((*A)(s,m));
ImageBuf &Rib ((*ot.curimg)(s,m));
bool ok = ImageBufAlgo::fixNonFinite (Rib, Aib, mode);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
}
ot.function_times["fixnan"] += timer();
return 0;
}
static int
action_fillholes (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fillholes, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Read and copy the top-of-stack image
ImageRecRef A (ot.pop());
ot.read (A);
ImageSpec spec = (*A)(0,0).spec();
set_roi (spec, roi_union (get_roi(spec), get_roi_full(spec)));
ImageRecRef B (new ImageRec("filled", spec, ot.imagecache));
ot.push (B);
ImageBuf &Rib ((*B)(0,0));
bool ok = ImageBufAlgo::fillholes_pushpull (Rib, (*A)(0,0));
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["fillholes"] += timer();
return 0;
}
static int
action_paste (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_paste, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef BG (ot.pop());
ImageRecRef FG (ot.pop());
ot.read (BG);
ot.read (FG);
int x = 0, y = 0;
if (sscanf (argv[1], "%d%d", &x, &y) != 2) {
ot.error ("paste", Strutil::format ("Invalid offset '%s'", argv[1]));
return 0;
}
ImageRecRef R (new ImageRec (*BG, 0, 0, true /* writable*/, true /* copy */));
ot.push (R);
bool ok = ImageBufAlgo::paste ((*R)(), x, y, 0, 0, (*FG)());
if (! ok)
ot.error (argv[0], (*R)().geterror());
ot.function_times["paste"] += timer();
return 0;
}
static int
action_mosaic (int argc, const char *argv[])
{
// Mosaic is tricky. We have to parse the argument before we know
// how many images it wants to pull off the stack.
int ximages = 0, yimages = 0;
if (sscanf (argv[1], "%dx%d", &ximages, &yimages) != 2
|| ximages < 1 || yimages < 1) {
ot.error ("mosaic", Strutil::format ("Invalid size '%s'", argv[1]));
return 0;
}
int nimages = ximages * yimages;
if (ot.postpone_callback (nimages, action_paste, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int widest = 0, highest = 0, nchannels = 0;
std::vector<ImageRecRef> images (nimages);
for (int i = nimages-1; i >= 0; --i) {
ImageRecRef img = ot.pop();
images[i] = img;
ot.read (img);
widest = std::max (widest, img->spec()->full_width);
highest = std::max (highest, img->spec()->full_height);
nchannels = std::max (nchannels, img->spec()->nchannels);
}
std::map<std::string,std::string> options;
options["pad"] = "0";
extract_options (options, argv[0]);
int pad = strtol (options["pad"].c_str(), NULL, 10);
ImageSpec Rspec (ximages*widest + (ximages-1)*pad,
yimages*highest + (yimages-1)*pad,
nchannels, TypeDesc::FLOAT);
ImageRecRef R (new ImageRec ("mosaic", Rspec, ot.imagecache));
ot.push (R);
ImageBufAlgo::zero ((*R)());
for (int j = 0; j < yimages; ++j) {
int y = j * (highest + pad);
for (int i = 0; i < ximages; ++i) {
int x = i * (widest + pad);
bool ok = ImageBufAlgo::paste ((*R)(), x, y, 0, 0,
(*images[j*ximages+i])(0));
if (! ok)
ot.error (argv[0], (*R)().geterror());
}
}
ot.function_times["mosaic"] += timer();
return 0;
}
static int
action_over (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_over, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
const ImageBuf &Aib ((*A)());
const ImageBuf &Bib ((*B)());
const ImageSpec &specA = Aib.spec();
const ImageSpec &specB = Bib.spec();
// Create output image specification.
ImageSpec specR = specA;
set_roi (specR, roi_union (get_roi(specA), get_roi(specB)));
set_roi_full (specR, roi_union (get_roi_full(specA), get_roi_full(specB)));
ot.push (new ImageRec ("over", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
bool ok = ImageBufAlgo::over (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["over"] += timer();
return 0;
}
static int
action_zover (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_zover, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Get optional flags
bool z_zeroisinf = false;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(cmd,"zeroisinf="))
z_zeroisinf = (atoi(cmd.c_str()+10) != 0);
}
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
const ImageBuf &Aib ((*A)());
const ImageBuf &Bib ((*B)());
const ImageSpec &specA = Aib.spec();
const ImageSpec &specB = Bib.spec();
// Create output image specification.
ImageSpec specR = specA;
set_roi (specR, roi_union (get_roi(specA), get_roi(specB)));
set_roi_full (specR, roi_union (get_roi_full(specA), get_roi_full(specB)));
ot.push (new ImageRec ("zover", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
bool ok = ImageBufAlgo::zover (Rib, Aib, Bib, z_zeroisinf);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["zover"] += timer();
return 0;
}
static int
action_flatten (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_flatten, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
const ImageBuf &Aib ((*A)());
const ImageSpec &specA = Aib.spec();
// Create output image specification.
ImageSpec specR = specA;
specR.deep = false;
ot.push (new ImageRec ("flatten", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
bool ok = ImageBufAlgo::flatten (Rib, Aib);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["flatten"] += timer();
return 0;
}
static int
action_fill (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fill, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Read and copy the top-of-stack image
ImageRecRef A (ot.pop());
ot.read (A);
ot.push (new ImageRec (*A, 0, 0, true, true /*copy_pixels*/));
ImageBuf &Rib ((*ot.curimg)(0,0));
const ImageSpec &Rspec = Rib.spec();
int w = Rib.spec().width, h = Rib.spec().height;
int x = Rib.spec().x, y = Rib.spec().y;
if (! ot.adjust_geometry (argv[0], w, h, x, y, argv[1], true)) {
return 0;
}
float *color = ALLOCA (float, Rspec.nchannels);
for (int c = 0; c < Rspec.nchannels; ++c)
color[c] = 1.0f;
// Parse optional arguments for overrides
std::string command = argv[0];
size_t pos;
while ((pos = command.find_first_of(":")) != std::string::npos) {
command = command.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(command,"color=")) {
// Parse comma-separated color list
size_t numpos = 6;
for (int c = 0; c < Rspec.nchannels && numpos < command.size() && command[numpos] != ':'; ++c) {
color[c] = (float) atof (command.c_str()+numpos);
while (numpos < command.size() && command[numpos] != ':' && command[numpos] != ',')
++numpos;
if (numpos < command.size())
++numpos;
}
}
}
bool ok = ImageBufAlgo::fill (Rib, color, ROI(x, x+w, y, y+h));
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["fill"] += timer();
return 0;
}
static int
action_clamp (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_clamp, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writeable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
int nchans = (*R)(s,0).nchannels();
const float big = std::numeric_limits<float>::max();
std::vector<float> min (nchans, -big);
std::vector<float> max (nchans, big);
std::map<std::string,std::string> options;
options["clampalpha"] = "0"; // initialize
extract_options (options, argv[0]);
Strutil::extract_from_list_string (min, options["min"]);
Strutil::extract_from_list_string (max, options["max"]);
bool clampalpha01 = strtol (options["clampalpha"].c_str(), NULL, 10) != 0;
for (int m = 0, miplevels=R->miplevels(s); m < miplevels; ++m) {
ImageBuf &Rib ((*R)(s,m));
ImageBuf &Aib ((*A)(s,m));
bool ok = ImageBufAlgo::clamp (Rib, Aib, &min[0], &max[0], clampalpha01);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
}
ot.function_times["clamp"] += timer();
return 0;
}
static int
action_rangecompress (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rangecompress, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string useluma_str = options["luma"];
bool useluma = useluma_str.size() && atoi(useluma_str.c_str()) != 0;
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::rangecompress ((*R)(s,m), (*A)(s,m), useluma);
if (! ok)
ot.error (argv[0], (*R)(s,m).geterror());
}
}
ot.function_times["rangecompress"] += timer();
return 0;
}
static int
action_rangeexpand (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rangeexpand, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string useluma_str = options["luma"];
bool useluma = useluma_str.size() && atoi(useluma_str.c_str()) != 0;
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::rangeexpand ((*R)(s,m), (*A)(s,m), useluma);
if (! ok)
ot.error (argv[0], (*R)(s,m).geterror());
}
}
ot.function_times["rangeexpand"] += timer();
return 0;
}
static int
action_text (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_text, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Read and copy the top-of-stack image
ImageRecRef A (ot.pop());
ot.read (A);
ot.push (new ImageRec (*A, 0, 0, true, true /*copy_pixels*/));
ImageBuf &Rib ((*ot.curimg)(0,0));
const ImageSpec &Rspec = Rib.spec();
// Set up defaults for text placement, size, font, color
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
int x = options["x"].size() ? Strutil::from_string<int>(options["x"]) : (Rspec.x + Rspec.width/2);
int y = options["y"].size() ? Strutil::from_string<int>(options["y"]) : (Rspec.y + Rspec.height/2);
int fontsize = options["size"].size() ? Strutil::from_string<int>(options["size"]) : 16;
std::string font = options["font"];
std::vector<float> textcolor (Rspec.nchannels, 1.0f);
Strutil::extract_from_list_string (textcolor, options["color"]);
bool ok = ImageBufAlgo::render_text (Rib, x, y, argv[1] /* the text */,
fontsize, font, &textcolor[0]);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["text"] += timer();
return 0;
}
/// action_histogram ---------------------------------------------------------
/// Usage:
/// ./oiiotool in --histogram:cumulative=int 'bins'x'height'
/// channel -o out
///
/// in - Input image that contains the channel to be histogramed.
/// cumulative - Optional argument that can take values 0 or 1. If 0,
/// then each bin will contain the count of pixels having
/// values in the range for that bin. If 1, then each bin
/// will contain not only its count, but also the counts of
/// all preceding bins.
/// 'bins'x'height' - Width and height of the histogram, where width equals
/// the number of bins.
/// channel - The channel in the input image to be histogramed.
/// out - Output image.
///
/// Examples:
/// - ./oiiotool in --histogram 256x256 0 -o out
///
/// Save the non-cumulative histogram of channel 0 in image
/// 'in', as an image with size 256x256.
///
/// - ./oiiotool in --histogram:cumulative=1 256x256 0 -o out
///
/// Same as the previous example, but now a cumulative
/// histogram is created, instead of a regular one.
/// --------------------------------------------------------------------------
static int
action_histogram (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (ot.postpone_callback (1, action_histogram, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Input image.
ot.read ();
ImageRecRef A (ot.pop());
const ImageBuf &Aib ((*A)());
// Get arguments from command line.
const char *size = argv[1];
int channel = atoi (argv[2]);
int cumulative = 0;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(cmd,"cumulative="))
cumulative = atoi(cmd.c_str()+11);
}
// Extract bins and height from size.
int bins = 0, height = 0;
if (sscanf (size, "%dx%d", &bins, &height) != 2) {
ot.error (argv[0], Strutil::format ("Invalid size: %s", size));
return -1;
}
// Compute regular histogram.
std::vector<imagesize_t> hist;
bool ok = ImageBufAlgo::histogram (Aib, channel, hist, bins);
if (! ok) {
ot.error (argv[0], Aib.geterror());
return 0;
}
// Compute cumulative histogram if specified.
if (cumulative == 1)
for (int i = 1; i < bins; i++)
hist[i] += hist[i-1];
// Output image.
ImageSpec specR (bins, height, 1, TypeDesc::FLOAT);
ot.push (new ImageRec ("irec", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
ok = ImageBufAlgo::histogram_draw (Rib, hist);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["histogram"] += timer();
return 0;
}
// Concatenate the command line into one string, optionally filtering out
// verbose attribute commands.
static std::string
command_line_string (int argc, char * argv[], bool sansattrib)
{
std::string s;
for (int i = 0; i < argc; ++i) {
if (sansattrib) {
// skip any filtered attributes
if (!strcmp(argv[i], "--attrib") || !strcmp(argv[i], "-attrib") ||
!strcmp(argv[i], "--sattrib") || !strcmp(argv[i], "-sattrib")) {
i += 2; // also skip the following arguments
continue;
}
if (!strcmp(argv[i], "--sansattrib") || !strcmp(argv[i], "-sansattrib")) {
continue;
}
}
if (strchr (argv[i], ' ')) { // double quote args with spaces
s += '\"';
s += argv[i];
s += '\"';
} else {
s += argv[i];
}
if (i < argc-1)
s += ' ';
}
return s;
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
bool sansattrib = false;
for (int i = 0; i < argc; ++i)
if (!strcmp(argv[i],"--sansattrib") || !strcmp(argv[i],"-sansattrib"))
sansattrib = true;
ot.full_command_line = command_line_string (argc, argv, sansattrib);
ArgParse ap (argc, (const char **)argv);
ap.options ("oiiotool -- simple image processing operations\n"
OIIO_INTRO_STRING "\n"
"Usage: oiiotool [filename,option,action]...\n",
"%*", input_file, "",
"<SEPARATOR>", "Options (general):",
"--help", &help, "Print help message",
"-v", &ot.verbose, "Verbose status messages",
"-q %!", &ot.verbose, "Quiet mode (turn verbose off)",
"--runstats", &ot.runstats, "Print runtime statistics",
"-a", &ot.allsubimages, "Do operations on all subimages/miplevels",
"--info", &ot.printinfo, "Print resolution and metadata on all inputs",
"--metamatch %s", &ot.printinfo_metamatch,
"Regex: which metadata is printed with -info -v",
"--no-metamatch %s", &ot.printinfo_nometamatch,
"Regex: which metadata is excluded with -info -v",
"--stats", &ot.printstats, "Print pixel statistics on all inputs",
"--dumpdata %@", set_dumpdata, NULL, "Print all pixel data values (options: empty=0)",
"--hash", &ot.hash, "Print SHA-1 hash of each input image",
"--colorcount %@ %s", action_colorcount, NULL,
"Count of how many pixels have the given color (argument: color;color;...) (options: eps=color)",
"--rangecheck %@ %s %s", action_rangecheck, NULL, NULL,
"Count of how many pixels are outside the low and high color arguments (each is a comma-separated color value list)",
// "-u", &ot.updatemode, "Update mode: skip outputs when the file exists and is newer than all inputs",
"--no-clobber", &ot.noclobber, "Do not overwrite existing files",
"--noclobber", &ot.noclobber, "", // synonym
"--threads %@ %d", set_threads, &ot.threads, "Number of threads (default 0 == #cores)",
"--frames %s", NULL, "Frame range for '#' or printf-style wildcards",
"--framepadding %d", NULL, "Frame number padding digits (ignored when using printf-style wildcards)",
"--views %s", NULL, "Views for %V/%v wildcards (comma-separated, defaults to left,right)",
"--wildcardoff", NULL, "Disable numeric wildcard expansion for subsequent command line arguments",
"--wildcardon", NULL, "Enable numeric wildcard expansion for subsequent command line arguments",
"--no-autopremult %@", unset_autopremult, NULL, "Turn off automatic premultiplication of images with unassociated alpha",
"--autopremult %@", set_autopremult, NULL, "Turn on automatic premultiplication of images with unassociated alpha",
"--autoorient", &ot.autoorient, "Automatically --reorient all images upon input",
"--auto-orient", &ot.autoorient, "", // symonym for --autoorient
"--native", &ot.nativeread, "Force native data type reads if cache would lose precision",
"<SEPARATOR>", "Commands that write images:",
"-o %@ %s", output_file, NULL, "Output the current image to the named file",
"<SEPARATOR>", "Options that affect subsequent image output:",
"-d %@ %s", set_dataformat, NULL,
"'-d TYPE' sets the output data format of all channels, "
"'-d CHAN=TYPE' overrides a single named channel (multiple -d args are allowed). "
"Data types include: uint8, sint8, uint10, uint12, uint16, sint16, uint32, sint32, half, float, double",
"--scanline", &ot.output_scanline, "Output scanline images",
"--tile %@ %d %d", output_tiles, &ot.output_tilewidth, &ot.output_tileheight,
"Output tiled images (tilewidth, tileheight)",
"--force-tiles", &ot.output_force_tiles, "", // undocumented
"--compression %s", &ot.output_compression, "Set the compression method",
"--quality %d", &ot.output_quality, "Set the compression quality, 1-100",
"--dither", &ot.output_dither, "Add dither to 8-bit output",
"--planarconfig %s", &ot.output_planarconfig,
"Force planarconfig (contig, separate, default)",
"--adjust-time", &ot.output_adjust_time,
"Adjust file times to match DateTime metadata",
"--noautocrop %!", &ot.output_autocrop,
"Do not automatically crop images whose formats don't support separate pixel data and full/display windows",
"--autotrim", &ot.output_autotrim,
"Automatically trim black borders upon output to file formats that support separate pixel data and full/display windows",
"<SEPARATOR>", "Options that change current image metadata (but not pixel values):",
"--attrib %@ %s %s", set_any_attribute, NULL, NULL, "Sets metadata attribute (name, value)",
"--sattrib %@ %s %s", set_string_attribute, NULL, NULL, "Sets string metadata attribute (name, value)",
"--caption %@ %s", set_caption, NULL, "Sets caption (ImageDescription metadata)",
"--keyword %@ %s", set_keyword, NULL, "Add a keyword",
"--clear-keywords %@", clear_keywords, NULL, "Clear all keywords",
"--nosoftwareattrib", &ot.metadata_nosoftwareattrib, "Do not write command line into Exif:ImageHistory, Software metadata attributes",
"--sansattrib", &sansattrib, "Write command line into Software & ImageHistory but remove --sattrib and --attrib options",
"--orientation %@ %d", set_orientation, NULL, "Set the assumed orientation",
"--orientcw %@", rotate_orientation, NULL, "Rotate orientation metadata 90 deg clockwise",
"--orientccw %@", rotate_orientation, NULL, "Rotate orientation metadata 90 deg counter-clockwise",
"--orient180 %@", rotate_orientation, NULL, "Rotate orientation metadata 180 deg",
"--rotcw %@", rotate_orientation, NULL, "", // DEPRECATED(1.5), back compatibility
"--rotccw %@", rotate_orientation, NULL, "", // DEPRECATED(1.5), back compatibility
"--rot180 %@", rotate_orientation, NULL, "", // DEPRECATED(1.5), back compatibility
"--origin %@ %s", set_origin, NULL,
"Set the pixel data window origin (e.g. +20+10)",
"--fullsize %@ %s", set_fullsize, NULL, "Set the display window (e.g., 1920x1080, 1024x768+100+0, -20-30)",
"--fullpixels %@", set_full_to_pixels, NULL, "Set the 'full' image range to be the pixel data window",
"--chnames %@ %s", set_channelnames, NULL,
"Set the channel names (comma-separated)",
"<SEPARATOR>", "Options that affect subsequent actions:",
"--fail %g", &ot.diff_failthresh, "Failure threshold difference (0.000001)",
"--failpercent %g", &ot.diff_failpercent, "Allow this percentage of failures in diff (0)",
"--hardfail %g", &ot.diff_hardfail, "Fail diff if any one pixel exceeds this error (infinity)",
"--warn %g", &ot.diff_warnthresh, "Warning threshold difference (0.00001)",
"--warnpercent %g", &ot.diff_warnpercent, "Allow this percentage of warnings in diff (0)",
"--hardwarn %g", &ot.diff_hardwarn, "Warn if any one pixel difference exceeds this error (infinity)",
"<SEPARATOR>", "Actions:",
"--create %@ %s %d", action_create, NULL, NULL,
"Create a blank image (args: geom, channels)",
"--pattern %@ %s %s %d", action_pattern, NULL, NULL, NULL,
"Create a patterned image (args: pattern, geom, channels)",
"--kernel %@ %s %s", action_kernel, NULL, NULL,
"Create a centered convolution kernel (args: name, geom)",
"--capture %@", action_capture, NULL,
"Capture an image (options: camera=%d)",
"--diff %@", action_diff, NULL, "Print report on the difference of two images (modified by --fail, --failpercent, --hardfail, --warn, --warnpercent --hardwarn)",
"--pdiff %@", action_pdiff, NULL, "Print report on the perceptual difference of two images (modified by --fail, --failpercent, --hardfail, --warn, --warnpercent --hardwarn)",
"--add %@", action_add, NULL, "Add two images",
"--sub %@", action_sub, NULL, "Subtract two images",
"--abs %@", action_abs, NULL, "Take the absolute value of the image pixels",
"--mul %@", action_mul, NULL, "Multiply two images",
"--cadd %s %@", action_cadd, NULL, "Add to all channels a scalar or per-channel constants (e.g.: 0.5 or 1,1.25,0.5)",
"--cmul %s %@", action_cmul, NULL, "Multiply the image values by a scalar or per-channel constants (e.g.: 0.5 or 1,1.25,0.5)",
"--cpow %s %@", action_cpow, NULL, "Raise the image values to a scalar or per-channel power (e.g.: 2.2 or 2.2,2.2,2.2,1.0)",
"--chsum %@", action_chsum, NULL,
"Turn into 1-channel image by summing channels (options: weight=r,g,...)",
"--crop %@ %s", action_crop, NULL, "Set pixel data resolution and offset, cropping or padding if necessary (WxH+X+Y or xmin,ymin,xmax,ymax)",
"--croptofull %@", action_croptofull, NULL, "Crop or pad to make pixel data region match the \"full\" region",
"--cut %@ %s", action_cut, NULL, "Cut out the ROI and reposition to the origin (WxH+X+Y or xmin,ymin,xmax,ymax)",
"--paste %@ %s", action_paste, NULL, "Paste fg over bg at the given position (e.g., +100+50)",
"--mosaic %@ %s", action_mosaic, NULL,
"Assemble images into a mosaic (arg: WxH; options: pad=0)",
"--over %@", action_over, NULL, "'Over' composite of two images",
"--zover %@", action_zover, NULL, "Depth composite two images with Z channels (options: zeroisinf=%d)",
"--histogram %@ %s %d", action_histogram, NULL, NULL, "Histogram one channel (options: cumulative=0)",
"--rotate90 %@", action_rotate90, NULL, "Rotate the image 90 degrees clockwise",
"--rotate180 %@", action_rotate180, NULL, "Rotate the image 180 degrees",
"--flipflop %@", action_rotate180, NULL, "", // Deprecated synonym for --rotate180
"--rotate270 %@", action_rotate270, NULL, "Rotate the image 270 degrees clockwise (or 90 degrees CCW)",
"--flip %@", action_flip, NULL, "Flip the image vertically (top<->bottom)",
"--flop %@", action_flop, NULL, "Flop the image horizontally (left<->right)",
"--reorient %@", action_reorient, NULL, "Rotate and/or flop the image to transform the pixels to match the Orientation metadata",
"--transpose %@", action_transpose, NULL, "Transpose the image",
"--cshift %@ %s", action_cshift, NULL, "Circular shift the image (e.g.: +20-10)",
"--resample %@ %s", action_resample, NULL, "Resample (640x480, 50%)",
"--resize %@ %s", action_resize, NULL, "Resize (640x480, 50%) (options: filter=%s)",
"--fit %@ %s", action_fit, NULL, "Resize to fit within a window size (options: filter=%s, pad=%d)",
"--rotate %@ %g", action_rotate, NULL, "Rotate pixels (argument is degrees clockwise) around the center of the display window (options: filter=%s, center=%f,%f, recompute_roi=%d",
"--warp %@ %s", action_warp, NULL, "Warp pixels (argument is a 3x3 matrix, separated by commas) (options: filter=%s, recompute_roi=%d)",
"--convolve %@", action_convolve, NULL,
"Convolve with a kernel",
"--blur %@ %s", action_blur, NULL,
"Blur the image (arg: WxH; options: kernel=name)",
"--median %@ %s", action_median, NULL,
"Median filter the image (arg: WxH)",
"--unsharp %@", action_unsharp, NULL,
"Unsharp mask (options: kernel=gaussian, width=3, contrast=1, threshold=0)",
"--fft %@", action_fft, NULL,
"Take the FFT of the image",
"--ifft %@", action_ifft, NULL,
"Take the inverse FFT of the image",
"--polar %@", action_polar, NULL,
"Convert complex (real,imag) to polar (amplitude,phase)",
"--unpolar %@", action_unpolar, NULL,
"Convert polar (amplitude,phase) to complex (real,imag)",
"--fixnan %@ %s", action_fixnan, NULL, "Fix NaN/Inf values in the image (options: none, black, box3)",
"--fillholes %@", action_fillholes, NULL,
"Fill in holes (where alpha is not 1)",
"--fill %@ %s", action_fill, NULL, "Fill a region (options: color=)",
"--clamp %@", action_clamp, NULL, "Clamp values (options: min=..., max=..., clampalpha=0)",
"--rangecompress %@", action_rangecompress, NULL,
"Compress the range of pixel values with a log scale (options: luma=0|1)",
"--rangeexpand %@", action_rangeexpand, NULL,
"Un-rangecompress pixel values back to a linear scale (options: luma=0|1)",
"--text %@ %s", action_text, NULL,
"Render text into the current image (options: x=, y=, size=, color=)",
"<SEPARATOR>", "Manipulating channels or subimages:",
"--ch %@ %s", action_channels, NULL,
"Select or shuffle channels (e.g., \"R,G,B\", \"B,G,R\", \"2,3,4\")",
"--chappend %@", action_chappend, NULL,
"Append the channels of the last two images",
"--unmip %@", action_unmip, NULL, "Discard all but the top level of a MIPmap",
"--selectmip %@ %d", action_selectmip, NULL,
"Select just one MIP level (0 = highest res)",
"--subimage %@ %d", action_select_subimage, NULL, "Select just one subimage",
"--siappend %@", action_subimage_append, NULL,
"Append the last two images into one multi-subimage image",
"--flatten %@", action_flatten, NULL, "Flatten deep image to non-deep",
"<SEPARATOR>", "Image stack manipulation:",
"--dup %@", action_dup, NULL,
"Duplicate the current image (push a copy onto the stack)",
"--swap %@", action_swap, NULL,
"Swap the top two images on the stack.",
"--pop %@", action_pop, NULL,
"Throw away the current image",
"--label %@ %s", action_label, NULL,
"Label the top image",
"<SEPARATOR>", "Color management:",
"--iscolorspace %@ %s", set_colorspace, NULL,
"Set the assumed color space (without altering pixels)",
"--tocolorspace %@ %s", action_tocolorspace, NULL,
"Convert the current image's pixels to a named color space",
"--colorconvert %@ %s %s", action_colorconvert, NULL, NULL,
"Convert pixels from 'src' to 'dst' color space (without regard to its previous interpretation)",
"--ociolook %@ %s", action_ociolook, NULL,
"Apply the named OCIO look (options: from=, to=, inverse=, key=, value=)",
"--ociodisplay %@ %s %s", action_ociodisplay, NULL, NULL,
"Apply the named OCIO display and view (options: from=, looks=, key=, value=)",
"--unpremult %@", action_unpremult, NULL,
"Divide all color channels of the current image by the alpha to \"un-premultiply\"",
"--premult %@", action_premult, NULL,
"Multiply all color channels of the current image by the alpha",
NULL);
if (ap.parse(argc, (const char**)argv) < 0) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
exit (EXIT_SUCCESS);
}
if (help || argc <= 1) {
ap.usage ();
// debugging color space names
std::stringstream s;
s << "Known color spaces: ";
const char *linear = ot.colorconfig.getColorSpaceNameByRole("linear");
for (int i = 0, e = ot.colorconfig.getNumColorSpaces(); i < e; ++i) {
const char *n = ot.colorconfig.getColorSpaceNameByIndex(i);
s << "\"" << n << "\"";
if (linear && !Strutil::iequals(n,"linear") &&
Strutil::iequals (n, linear))
s << " (linear)";
if (i < e-1)
s << ", ";
}
int columns = Sysutil::terminal_columns() - 2;
std::cout << Strutil::wordwrap(s.str(), columns, 4) << "\n";
int nlooks = ot.colorconfig.getNumLooks();
if (nlooks) {
std::stringstream s;
s << "Known looks: ";
for (int i = 0; i < nlooks; ++i) {
const char *n = ot.colorconfig.getLookNameByIndex(i);
s << "\"" << n << "\"";
if (i < nlooks-1)
s << ", ";
}
std::cout << Strutil::wordwrap(s.str(), columns, 4) << "\n";
}
const char *default_display = ot.colorconfig.getDefaultDisplayName();
int ndisplays = ot.colorconfig.getNumDisplays();
if (ndisplays) {
std::stringstream s;
s << "Known displays: ";
for (int i = 0; i < ndisplays; ++i) {
const char *d = ot.colorconfig.getDisplayNameByIndex(i);
s << "\"" << d << "\"";
if (! strcmp(d, default_display))
s << "*";
const char *default_view = ot.colorconfig.getDefaultViewName(d);
int nviews = ot.colorconfig.getNumViews(d);
if (nviews) {
s << " (views: ";
for (int i = 0; i < nviews; ++i) {
const char *v = ot.colorconfig.getViewNameByIndex(d, i);
s << "\"" << v << "\"";
if (! strcmp(v, default_view))
s << "*";
if (i < nviews-1)
s << ", ";
}
s << ")";
}
if (i < ndisplays-1)
s << ", ";
}
s << " (* = default)";
std::cout << Strutil::wordwrap(s.str(), columns, 4) << "\n";
}
if (! ot.colorconfig.supportsOpenColorIO())
std::cout << "No OpenColorIO support was enabled at build time.\n";
exit (EXIT_SUCCESS);
}
}
// Check if any of the command line arguments contains numeric ranges or
// wildcards. If not, just return 'false'. But if they do, the
// remainder of processing will happen here (and return 'true').
static bool
handle_sequence (int argc, const char **argv)
{
Timer totaltime;
// First, scan the original command line arguments for '#', '@', '%0Nd',
// '%v' or '%V' characters. Any found indicate that there are numeric
// range or wildcards to deal with. Also look for --frames,
// --framepadding and --views options.
#define ONERANGE_SPEC "[0-9]+(-[0-9]+((x|y)-?[0-9]+)?)?"
#define MANYRANGE_SPEC ONERANGE_SPEC "(," ONERANGE_SPEC ")*"
#define VIEW_SPEC "%[Vv]"
#define SEQUENCE_SPEC "((" MANYRANGE_SPEC ")?" "((#|@)+|(%[0-9]*d)))" "|" "(" VIEW_SPEC ")"
static boost::regex sequence_re (SEQUENCE_SPEC);
std::string framespec = "";
static const char *default_views = "left,right";
std::vector<string_view> views;
Strutil::split (default_views, views, ",");
int framepadding = 0;
std::vector<int> sequence_args; // Args with sequence numbers
std::vector<bool> sequence_is_output;
bool is_sequence = false;
bool wildcard_on = true;
for (int a = 1; a < argc; ++a) {
bool is_output = false;
if (! strcmp (argv[a], "-o") && a < argc-1) {
is_output = true;
a++;
}
std::string strarg (argv[a]);
boost::match_results<std::string::const_iterator> range_match;
if ((strarg == "--frames" || strarg == "-frames") && a < argc-1) {
framespec = argv[++a];
}
else if ((strarg == "--framepadding" || strarg == "-framepadding")
&& a < argc-1) {
int f = atoi (argv[++a]);
if (f >= 1 && f < 10)
framepadding = f;
}
else if ((strarg == "--views" || strarg == "-views") && a < argc-1) {
Strutil::split (argv[++a], views, ",");
}
else if (strarg == "--wildcardoff" || strarg == "-wildcardoff") {
wildcard_on = false;
}
else if (strarg == "--wildcardon" || strarg == "-wildcardon") {
wildcard_on = true;
}
else if (wildcard_on &&
boost::regex_search (strarg, range_match, sequence_re)) {
is_sequence = true;
sequence_args.push_back (a);
sequence_is_output.push_back (is_output);
}
}
// No ranges or wildcards?
if (! is_sequence)
return false;
// For each of the arguments that contains a wildcard, get a normalized
// pattern in printf style (e.g. "foo.%04d.exr"). Next, either expand the
// frame pattern to a list of frame numbers and use enumerate_file_sequence
// to fully elaborate all the filenames in the sequence, or if no frame
// range was specified, scan the filesystem for matching frames. Output
// sequences without explicit frame ranges inherit the frame numbers of
// the first input sequence. It's an error if the sequences are not all
// of the same length.
std::vector< std::vector<std::string> > filenames (argc+1);
std::vector< std::vector<int> > frame_numbers (argc+1);
std::vector< std::vector<string_view> > frame_views (argc+1);
std::string normalized_pattern, sequence_framespec;
size_t nfilenames = 0;
bool result;
for (size_t i = 0; i < sequence_args.size(); ++i) {
int a = sequence_args[i];
result = Filesystem::parse_pattern (argv[a],
framepadding,
normalized_pattern,
sequence_framespec);
if (! result) {
ot.error (Strutil::format("Could not parse pattern: %s",
argv[a]), "");
return true;
}
// --frames overrides sequence framespec
if (! framespec.empty())
sequence_framespec = framespec;
if (! sequence_framespec.empty()) {
Filesystem::enumerate_sequence (sequence_framespec.c_str(),
frame_numbers[a]);
Filesystem::enumerate_file_sequence (normalized_pattern,
frame_numbers[a],
views,
filenames[a]);
} else if (sequence_is_output[i]) {
// use frame numbers from first sequence
Filesystem::enumerate_file_sequence (normalized_pattern,
frame_numbers[sequence_args[0]],
frame_views[sequence_args[0]],
filenames[a]);
} else if (! sequence_is_output[i]) {
result = Filesystem::scan_for_matching_filenames (normalized_pattern,
views,
frame_numbers[a],
frame_views[a],
filenames[a]);
if (! result) {
ot.error (Strutil::format("No filenames found matching pattern: \"%s\" (did you intend to use --wildcardoff?)",
argv[a]), "");
return true;
}
}
if (i == 0) {
nfilenames = filenames[a].size();
} else if (nfilenames != filenames[a].size()) {
ot.error (Strutil::format("Not all sequence specifications matched: %s (%d frames) vs. %s (%d frames)",
argv[sequence_args[0]], nfilenames, argv[a], filenames[a].size()), "");
return true;
}
}
// OK, now we just call getargs once for each item in the sequences,
// substituting the i-th sequence entry for its respective argument
// every time.
std::vector<const char *> seq_argv (argv, argv+argc+1);
for (size_t i = 0; i < nfilenames; ++i) {
for (size_t j = 0; j < sequence_args.size(); ++j) {
size_t a = sequence_args[j];
seq_argv[a] = filenames[a][i].c_str();
}
ot.clear_options (); // Careful to reset all command line options!
getargs (argc, (char **)&seq_argv[0]);
ot.process_pending ();
if (ot.pending_callback())
ot.warning (Strutil::format ("pending '%s' command never executed", ot.pending_callback_name()));
// Clear the stack at the end of each iteration
ot.curimg.reset ();
ot.image_stack.clear();
if (ot.runstats)
std::cout << "End iteration " << i << ": "
<< Strutil::timeintervalformat(totaltime(),2) << " "
<< Strutil::memformat(Sysutil::memory_used()) << "\n";
}
return true;
}
int
main (int argc, char *argv[])
{
// When Visual Studio is used float values in scientific format are printed
// with three digit exponent. We change this behavior to fit the Linux way.
#ifdef _MSC_VER
_set_output_format (_TWO_DIGIT_EXPONENT);
#endif
Timer totaltime;
ot.imagecache = ImageCache::create (false);
ASSERT (ot.imagecache);
ot.imagecache->attribute ("forcefloat", 1);
ot.imagecache->attribute ("m_max_memory_MB", 4096.0);
// ot.imagecache->attribute ("autotile", 1024);
Filesystem::convert_native_arguments (argc, (const char **)argv);
if (handle_sequence (argc, (const char **)argv)) {
// Deal with sequence
} else {
// Not a sequence
getargs (argc, argv);
ot.process_pending ();
if (ot.pending_callback())
ot.warning (Strutil::format ("pending '%s' command never executed", ot.pending_callback_name()));
}
if (ot.runstats) {
double total_time = totaltime();
double unaccounted = total_time;
std::cout << "\n";
int threads = -1;
OIIO::getattribute ("threads", threads);
std::cout << "Threads: " << threads << "\n";
std::cout << "oiiotool runtime statistics:\n";
std::cout << " Total time: " << Strutil::timeintervalformat(total_time,2) << "\n";
static const char *timeformat = " %-12s : %5.2f\n";
for (Oiiotool::TimingMap::const_iterator func = ot.function_times.begin();
func != ot.function_times.end(); ++func) {
double t = func->second;
std::cout << Strutil::format (timeformat, func->first, t);
unaccounted -= t;
}
std::cout << Strutil::format (timeformat, "unaccounted", std::max(unaccounted, 0.0));
std::cout << ot.imagecache->getstats() << "\n";
}
return ot.return_value;
}
oiiotool --chnames fix to the way channel names are changed in the spec
(was putting it in the IR's spec, but not the underlying IB's spec).
/*
Copyright 2011 Larry Gritz and the other authors and contributors.
All Rights Reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the software's owners nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(This is the Modified BSD License)
*/
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iterator>
#include <vector>
#include <string>
#include <sstream>
#include <utility>
#include <ctype.h>
#include <map>
#include <boost/tokenizer.hpp>
#include <boost/foreach.hpp>
#include <boost/regex.hpp>
#include "OpenImageIO/argparse.h"
#include "OpenImageIO/imageio.h"
#include "OpenImageIO/imagebuf.h"
#include "OpenImageIO/imagebufalgo.h"
#include "OpenImageIO/sysutil.h"
#include "OpenImageIO/filesystem.h"
#include "OpenImageIO/filter.h"
#include "OpenImageIO/color.h"
#include "OpenImageIO/timer.h"
#include "oiiotool.h"
OIIO_NAMESPACE_USING
using namespace OiioTool;
using namespace ImageBufAlgo;
static Oiiotool ot;
Oiiotool::Oiiotool ()
: imagecache(NULL),
return_value (EXIT_SUCCESS),
total_readtime (false /*don't start timer*/),
total_writetime (false /*don't start timer*/),
total_imagecache_readtime (0.0),
enable_function_timing(true)
{
clear_options ();
}
void
Oiiotool::clear_options ()
{
verbose = false;
runstats = false;
noclobber = false;
allsubimages = false;
printinfo = false;
printstats = false;
dumpdata = false;
dumpdata_showempty = true;
hash = false;
updatemode = false;
autoorient = false;
nativeread = false;
threads = 0;
full_command_line.clear ();
printinfo_metamatch.clear ();
printinfo_nometamatch.clear ();
output_dataformat = TypeDesc::UNKNOWN;
output_channelformats.clear ();
output_bitspersample = 0;
output_scanline = false;
output_tilewidth = 0;
output_tileheight = 0;
output_compression = "";
output_quality = -1;
output_planarconfig = "default";
output_adjust_time = false;
output_autocrop = true;
output_autotrim = false;
output_dither = false;
output_force_tiles = false;
metadata_nosoftwareattrib = false;
diff_warnthresh = 1.0e-6f;
diff_warnpercent = 0;
diff_hardwarn = std::numeric_limits<float>::max();
diff_failthresh = 1.0e-6f;
diff_failpercent = 0;
diff_hardfail = std::numeric_limits<float>::max();
m_pending_callback = NULL;
m_pending_argc = 0;
}
std::string
format_resolution (int w, int h, int x, int y)
{
return Strutil::format ("%dx%d%+d%+d", w, h, x, y);
}
std::string
format_resolution (int w, int h, int d, int x, int y, int z)
{
return Strutil::format ("%dx%dx%d%+d%+d%+d", w, h, d, x, y, z);
}
// FIXME -- lots of things we skimped on so far:
// FIXME: check binary ops for compatible image dimensions
// FIXME: handle missing image
// FIXME: reject volume images?
// FIXME: do all ops respect -a (or lack thereof?)
bool
Oiiotool::read (ImageRecRef img)
{
// If the image is already elaborated, take an early out, both to
// save time, but also because we only want to do the format and
// tile adjustments below as images are read in fresh from disk.
if (img->elaborated())
return true;
// Cause the ImageRec to get read. Try to compute how long it took.
// Subtract out ImageCache time, to avoid double-accounting it later.
float pre_ic_time, post_ic_time;
imagecache->getattribute ("stat:fileio_time", pre_ic_time);
total_readtime.start ();
bool ok = img->read (ot.nativeread);
total_readtime.stop ();
imagecache->getattribute ("stat:fileio_time", post_ic_time);
total_imagecache_readtime += post_ic_time - pre_ic_time;
// If this is the first tiled image we have come across, use it to
// set our tile size (unless the user explicitly set a tile size, or
// explicitly instructed scanline output).
const ImageSpec &nspec ((*img)().nativespec());
if (nspec.tile_width && ! output_tilewidth && ! ot.output_scanline) {
output_tilewidth = nspec.tile_width;
output_tileheight = nspec.tile_height;
}
// If we do not yet have an expected output format, set it based on
// this image (presumably the first one read.
if (output_dataformat == TypeDesc::UNKNOWN) {
output_dataformat = nspec.format;
if (! output_bitspersample)
output_bitspersample = nspec.get_int_attribute ("oiio:BitsPerSample");
}
if (! ok) {
error ("read "+img->name(), img->geterror());
}
return ok;
}
bool
Oiiotool::postpone_callback (int required_images, CallbackFunction func,
int argc, const char *argv[])
{
if (((curimg ? 1 : 0) + (int)image_stack.size()) < required_images) {
// Not enough have inputs been specified so far, so put this
// function on the "pending" list.
m_pending_callback = func;
m_pending_argc = argc;
for (int i = 0; i < argc; ++i)
m_pending_argv[i] = ustring(argv[i]).c_str();
return true;
}
return false;
}
void
Oiiotool::process_pending ()
{
// Process any pending command -- this is a case where the
// command line had prefix 'oiiotool --action file1 file2'
// instead of infix 'oiiotool file1 --action file2'.
if (m_pending_callback) {
int argc = m_pending_argc;
const char *argv[4];
for (int i = 0; i < argc; ++i)
argv[i] = m_pending_argv[i];
CallbackFunction callback = m_pending_callback;
m_pending_callback = NULL;
m_pending_argc = 0;
(*callback) (argc, argv);
}
}
void
Oiiotool::error (string_view command, string_view explanation)
{
std::cerr << "oiiotool ERROR: " << command;
if (explanation.length())
std::cerr << " (" << explanation << ")";
std::cerr << "\n";
exit (-1);
}
void
Oiiotool::warning (string_view command, string_view explanation)
{
std::cerr << "oiiotool WARNING: " << command;
if (explanation.length())
std::cerr << " (" << explanation << ")";
std::cerr << "\n";
}
static int
extract_options (std::map<std::string,std::string> &options,
std::string command)
{
// std::cout << "extract_options '" << command << "'\n";
int noptions = 0;
size_t pos;
while ((pos = command.find_first_of(":")) != std::string::npos) {
command = command.substr (pos+1, std::string::npos);
size_t e = command.find_first_of("=");
if (e != std::string::npos) {
std::string name = command.substr(0,e);
std::string value = command.substr(e+1,command.find_first_of(":")-(e+1));
options[name] = value;
++noptions;
// std::cout << "'" << name << "' -> '" << value << "'\n";
}
}
return noptions;
}
static int
set_threads (int argc, const char *argv[])
{
ASSERT (argc == 2);
OIIO::attribute ("threads", atoi(argv[1]));
return 0;
}
static int
set_dumpdata (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.dumpdata = true;
std::map<std::string,std::string> options;
options["empty"] = "1";
extract_options (options, argv[0]);
ot.dumpdata_showempty = Strutil::from_string<int> (options["empty"]);
return 0;
}
static int
set_autopremult (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.imagecache->attribute ("unassociatedalpha", 0);
return 0;
}
static int
unset_autopremult (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.imagecache->attribute ("unassociatedalpha", 1);
return 0;
}
static int
input_file (int argc, const char *argv[])
{
for (int i = 0; i < argc; i++) {
std::map<std::string,ImageRecRef>::const_iterator found;
found = ot.image_labels.find(argv[i]);
if (found != ot.image_labels.end()) {
if (ot.verbose)
std::cout << "Referencing labeled image " << argv[i] << "\n";
ot.push (found->second);
ot.process_pending ();
break;
}
Timer timer (ot.enable_function_timing);
int exists = 1;
if (! ot.imagecache->get_image_info (ustring(argv[i]), 0, 0,
ustring("exists"), TypeDesc::TypeInt, &exists)
|| !exists) {
ot.error ("read", Strutil::format ("Could not open file \"%s\"", argv[i]));
exit (1);
}
if (ot.verbose)
std::cout << "Reading " << argv[i] << "\n";
ot.push (ImageRecRef (new ImageRec (argv[i], ot.imagecache)));
if (ot.printinfo || ot.printstats || ot.dumpdata || ot.hash) {
OiioTool::print_info_options pio;
pio.verbose = ot.verbose;
pio.subimages = ot.allsubimages;
pio.compute_stats = ot.printstats;
pio.dumpdata = ot.dumpdata;
pio.dumpdata_showempty = ot.dumpdata_showempty;
pio.compute_sha1 = ot.hash;
pio.metamatch = ot.printinfo_metamatch;
pio.nometamatch = ot.printinfo_nometamatch;
long long totalsize = 0;
std::string error;
bool ok = OiioTool::print_info (ot, argv[i], pio, totalsize, error);
if (! ok)
ot.error ("read", error);
}
ot.function_times["input"] += timer();
if (ot.autoorient) {
int action_reorient (int argc, const char *argv[]);
const char *argv[] = { "--reorient" };
action_reorient (1, argv);
}
ot.process_pending ();
}
return 0;
}
static int
action_label (int argc, const char *argv[])
{
ot.image_labels[argv[1]] = ot.curimg;
return 0;
}
static void
string_to_dataformat (const std::string &s, TypeDesc &dataformat, int &bits)
{
if (s == "uint8") {
dataformat = TypeDesc::UINT8; bits = 0;
} else if (s == "int8") {
dataformat = TypeDesc::INT8; bits = 0;
} else if (s == "uint10") {
dataformat = TypeDesc::UINT16; bits = 10;
} else if (s == "uint12") {
dataformat = TypeDesc::UINT16; bits = 12;
} else if (s == "uint16") {
dataformat = TypeDesc::UINT16; bits = 0;
} else if (s == "int16") {
dataformat = TypeDesc::INT16; bits = 0;
} else if (s == "uint32") {
dataformat = TypeDesc::UINT32; bits = 0;
} else if (s == "int32") {
dataformat = TypeDesc::INT32; bits = 0;
} else if (s == "half") {
dataformat = TypeDesc::HALF; bits = 0;
} else if (s == "float") {
dataformat = TypeDesc::FLOAT; bits = 0;
} else if (s == "double") {
dataformat = TypeDesc::DOUBLE; bits = 0;
}
}
static void
adjust_output_options (string_view filename,
ImageSpec &spec, const Oiiotool &ot,
bool format_supports_tiles)
{
if (ot.output_dataformat != TypeDesc::UNKNOWN) {
spec.set_format (ot.output_dataformat);
if (ot.output_bitspersample != 0)
spec.attribute ("oiio:BitsPerSample", ot.output_bitspersample);
else
spec.erase_attribute ("oiio:BitsPerSample");
}
if (ot.output_channelformats.size()) {
spec.channelformats.clear ();
spec.channelformats.resize (spec.nchannels, spec.format);
for (int c = 0; c < spec.nchannels; ++c) {
if (c >= (int)spec.channelnames.size())
break;
std::map<std::string,std::string>::const_iterator i = ot.output_channelformats.find (spec.channelnames[c]);
if (i != ot.output_channelformats.end()) {
int bits = 0;
string_to_dataformat (i->second, spec.channelformats[c], bits);
}
}
bool allsame = true;
if (spec.channelnames.size())
for (int c = 1; c < spec.nchannels; ++c)
allsame &= (spec.channelformats[c] == spec.channelformats[0]);
if (allsame) {
spec.format = spec.channelformats[0];
spec.channelformats.clear();
}
} else {
spec.channelformats.clear ();
}
// If we've had tiled input and scanline was not explicitly
// requested, we'll try tiled output.
if (ot.output_tilewidth && !ot.output_scanline && format_supports_tiles) {
spec.tile_width = ot.output_tilewidth;
spec.tile_height = ot.output_tileheight;
spec.tile_depth = 1;
} else {
spec.tile_width = spec.tile_height = spec.tile_depth = 0;
}
if (! ot.output_compression.empty())
spec.attribute ("compression", ot.output_compression);
if (ot.output_quality > 0)
spec.attribute ("CompressionQuality", ot.output_quality);
if (ot.output_planarconfig == "contig" ||
ot.output_planarconfig == "separate")
spec.attribute ("planarconfig", ot.output_planarconfig);
// Append command to image history. Sometimes we may not want to recite the
// entire command line (eg. when we have loaded it up with metadata attributes
// that will make it into the header anyway).
if (! ot.metadata_nosoftwareattrib) {
std::string history = spec.get_string_attribute ("Exif:ImageHistory");
if (! Strutil::iends_with (history, ot.full_command_line)) { // don't add twice
if (history.length() && ! Strutil::iends_with (history, "\n"))
history += std::string("\n");
history += ot.full_command_line;
spec.attribute ("Exif:ImageHistory", history);
}
std::string software = Strutil::format ("OpenImageIO %s : %s",
OIIO_VERSION_STRING, ot.full_command_line);
spec.attribute ("Software", software);
}
if (ot.output_dither) {
int h = (int) Strutil::strhash(filename);
if (!h)
h = 1;
spec.attribute ("oiio:dither", h);
}
// Make sure we kill any special hints that maketx adds and that will
// no longer be valid after whatever oiiotool operations we've done.
spec.erase_attribute ("oiio:SHA-1");
spec.erase_attribute ("oiio:ConstantColor");
spec.erase_attribute ("oiio:AverageColor");
}
static bool
DateTime_to_time_t (const char *datetime, time_t &timet)
{
int year, month, day, hour, min, sec;
int r = sscanf (datetime, "%d:%d:%d %d:%d:%d",
&year, &month, &day, &hour, &min, &sec);
// printf ("%d %d:%d:%d %d:%d:%d\n", r, year, month, day, hour, min, sec);
if (r != 6)
return false;
struct tm tmtime;
time_t now;
Sysutil::get_local_time (&now, &tmtime); // fill in defaults
tmtime.tm_sec = sec;
tmtime.tm_min = min;
tmtime.tm_hour = hour;
tmtime.tm_mday = day;
tmtime.tm_mon = month-1;
tmtime.tm_year = year-1900;
timet = mktime (&tmtime);
return true;
}
static int
output_file (int argc, const char *argv[])
{
ASSERT (argc == 2 && !strcmp(argv[0],"-o"));
Timer timer (ot.enable_function_timing);
ot.total_writetime.start();
std::string filename = argv[1];
if (! ot.curimg.get()) {
ot.warning ("output", filename + " did not have any current image to output.");
return 0;
}
if (ot.noclobber && Filesystem::exists(filename)) {
ot.warning ("output", filename + " already exists, not overwriting.");
return 0;
}
if (ot.verbose)
std::cout << "Writing " << argv[1] << "\n";
ImageOutput *out = ImageOutput::create (filename.c_str());
if (! out) {
ot.error ("output", OIIO::geterror());
return 0;
}
bool supports_displaywindow = out->supports ("displaywindow");
bool supports_negativeorigin = out->supports ("negativeorigin");
bool supports_tiles = out->supports ("tiles") || ot.output_force_tiles;
ot.read ();
ImageRecRef saveimg = ot.curimg;
ImageRecRef ir (ot.curimg);
// Handle --autotrim
if (supports_displaywindow && ot.output_autotrim) {
ROI origroi = get_roi(*ir->spec(0,0));
ROI roi = ImageBufAlgo::nonzero_region ((*ir)(0,0), origroi);
if (roi.npixels() == 0) {
// Special case -- all zero; but doctor to make it 1 zero pixel
roi = origroi;
roi.xend = roi.xbegin+1;
roi.yend = roi.ybegin+1;
roi.zend = roi.zbegin+1;
}
std::string crop = (ir->spec(0,0)->depth == 1)
? format_resolution (roi.width(), roi.height(),
roi.xbegin, roi.ybegin)
: format_resolution (roi.width(), roi.height(), roi.depth(),
roi.xbegin, roi.ybegin, roi.zbegin);
const char *argv[] = { "crop", crop.c_str() };
int action_crop (int argc, const char *argv[]); // forward decl
action_crop (2, argv);
ir = ot.curimg;
}
// Automatically crop/pad if outputting to a format that doesn't
// support display windows, unless autocrop is disabled.
if (! supports_displaywindow && ot.output_autocrop &&
(ir->spec()->x != ir->spec()->full_x ||
ir->spec()->y != ir->spec()->full_y ||
ir->spec()->width != ir->spec()->full_width ||
ir->spec()->height != ir->spec()->full_height)) {
const char *argv[] = { "croptofull" };
int action_croptofull (int argc, const char *argv[]); // forward decl
action_croptofull (1, argv);
ir = ot.curimg;
}
// Automatically crop out the negative areas if outputting to a format
// that doesn't support negative origins.
if (! supports_negativeorigin && ot.output_autocrop &&
(ir->spec()->x < 0 || ir->spec()->y < 0 || ir->spec()->z < 0)) {
ROI roi = get_roi (*ir->spec(0,0));
roi.xbegin = std::max (0, roi.xbegin);
roi.ybegin = std::max (0, roi.ybegin);
roi.zbegin = std::max (0, roi.zbegin);
std::string crop = (ir->spec(0,0)->depth == 1)
? format_resolution (roi.width(), roi.height(),
roi.xbegin, roi.ybegin)
: format_resolution (roi.width(), roi.height(), roi.depth(),
roi.xbegin, roi.ybegin, roi.zbegin);
const char *argv[] = { "crop", crop.c_str() };
int action_crop (int argc, const char *argv[]); // forward decl
action_crop (2, argv);
ir = ot.curimg;
}
// FIXME -- both autotrim and autocrop above neglect to handle
// MIPmaps or subimages with full generality.
std::vector<ImageSpec> subimagespecs (ir->subimages());
for (int s = 0; s < ir->subimages(); ++s) {
ImageSpec spec = *ir->spec(s,0);
adjust_output_options (filename, spec, ot, supports_tiles);
// For deep files, must copy the native deep channelformats
if (spec.deep)
spec.channelformats = (*ir)(s,0).nativespec().channelformats;
subimagespecs[s] = spec;
}
// Do the initial open
ImageOutput::OpenMode mode = ImageOutput::Create;
if (ir->subimages() > 1 && out->supports("multiimage")) {
if (! out->open (filename, ir->subimages(), &subimagespecs[0])) {
ot.error ("output", out->geterror());
return 0;
}
} else {
if (! out->open (filename, subimagespecs[0], mode)) {
ot.error ("output", out->geterror());
return 0;
}
}
// Output all the subimages and MIP levels
for (int s = 0, send = ir->subimages(); s < send; ++s) {
for (int m = 0, mend = ir->miplevels(s); m < mend; ++m) {
ImageSpec spec = *ir->spec(s,m);
adjust_output_options (filename, spec, ot, supports_tiles);
if (s > 0 || m > 0) { // already opened first subimage/level
if (! out->open (filename, spec, mode)) {
ot.error ("output", out->geterror());
return 0;
}
}
if (! (*ir)(s,m).write (out)) {
ot.error ("output", (*ir)(s,m).geterror());
return 0;
}
if (mend > 1) {
if (out->supports("mipmap")) {
mode = ImageOutput::AppendMIPLevel; // for next level
} else if (out->supports("multiimage")) {
mode = ImageOutput::AppendSubimage;
} else {
ot.warning ("output", Strutil::format ("%s does not support MIP-maps for %s",
out->format_name(), filename));
break;
}
}
}
mode = ImageOutput::AppendSubimage; // for next subimage
if (send > 1 && ! out->supports("multiimage")) {
ot.warning ("output", Strutil::format ("%s does not support multiple subimages for %s",
out->format_name(), filename));
break;
}
}
out->close ();
delete out;
if (ot.output_adjust_time) {
std::string metadatatime = ir->spec(0,0)->get_string_attribute ("DateTime");
std::time_t in_time = ir->time();
if (! metadatatime.empty())
DateTime_to_time_t (metadatatime.c_str(), in_time);
Filesystem::last_write_time (filename, in_time);
}
ot.curimg = saveimg;
ot.total_writetime.stop();
ot.function_times["output"] += timer();
return 0;
}
static int
set_dataformat (int argc, const char *argv[])
{
ASSERT (argc == 2);
std::vector<std::string> chans;
Strutil::split (argv[1], chans, ",");
if (chans.size() == 0) {
return 0; // Nothing to do
}
if (chans.size() == 1 && !strchr(chans[0].c_str(),'=')) {
// Of the form: -d uint8 (for example)
// Just one default format designated, apply to all channels
ot.output_dataformat = TypeDesc::UNKNOWN;
ot.output_bitspersample = 0;
string_to_dataformat (chans[0], ot.output_dataformat,
ot.output_bitspersample);
ot.output_channelformats.clear ();
return 0; // we're done
}
// If we make it here, the format designator was of the form
// name0=type0,name1=type1,...
for (size_t i = 0; i < chans.size(); ++i) {
const char *eq = strchr(chans[i].c_str(),'=');
if (eq) {
std::string channame (chans[i], 0, eq - chans[i].c_str());
ot.output_channelformats[channame] = std::string (eq+1);
} else {
ot.error (argv[0], Strutil::format ("Malformed format designator \"%s\"", chans[i]));
}
}
return 0;
}
static int
set_string_attribute (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
set_attribute (ot.curimg, argv[1], TypeDesc::TypeString, argv[2]);
return 0;
}
static int
set_any_attribute (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
set_attribute (ot.curimg, argv[1], TypeDesc(TypeDesc::UNKNOWN), argv[2]);
return 0;
}
static bool
do_erase_attribute (ImageSpec &spec, const std::string &attribname)
{
spec.erase_attribute (attribname);
return true;
}
template<class T>
static bool
do_set_any_attribute (ImageSpec &spec, const std::pair<std::string,T> &x)
{
spec.attribute (x.first, x.second);
return true;
}
bool
Oiiotool::adjust_geometry (string_view command,
int &w, int &h, int &x, int &y, const char *geom,
bool allow_scaling)
{
float scaleX = 1.0f;
float scaleY = 1.0f;
int ww = w, hh = h;
int xx = x, yy = y;
int xmax, ymax;
if (sscanf (geom, "%d,%d,%d,%d", &xx, &yy, &xmax, &ymax) == 4) {
x = xx;
y = yy;
w = std::max (0, xmax-xx+1);
h = std::max (0, ymax-yy+1);
} else if (sscanf (geom, "%dx%d%d%d", &ww, &hh, &xx, &yy) == 4) {
if (ww == 0 && h != 0)
ww = int (hh * float(w)/float(h) + 0.5f);
if (hh == 0 && w != 0)
hh = int (ww * float(h)/float(w) + 0.5f);
w = ww;
h = hh;
x = xx;
y = yy;
} else if (sscanf (geom, "%dx%d", &ww, &hh) == 2) {
if (ww == 0 && h != 0)
ww = int (hh * float(w)/float(h) + 0.5f);
if (hh == 0 && w != 0)
hh = int (ww * float(h)/float(w) + 0.5f);
w = ww;
h = hh;
} else if (allow_scaling && sscanf (geom, "%f%%x%f%%", &scaleX, &scaleY) == 2) {
scaleX = std::max(0.0f, scaleX*0.01f);
scaleY = std::max(0.0f, scaleY*0.01f);
if (scaleX == 0 && scaleY != 0)
scaleX = scaleY;
if (scaleY == 0 && scaleX != 0)
scaleY = scaleX;
w = (int)(w * scaleX + 0.5f);
h = (int)(h * scaleY + 0.5f);
} else if (sscanf (geom, "%d%d", &xx, &yy) == 2) {
x = xx;
y = yy;
} else if (allow_scaling && sscanf (geom, "%f%%", &scaleX) == 1) {
scaleX *= 0.01f;
w = (int)(w * scaleX + 0.5f);
h = (int)(h * scaleX + 0.5f);
} else if (allow_scaling && sscanf (geom, "%f", &scaleX) == 1) {
w = (int)(w * scaleX + 0.5f);
h = (int)(h * scaleX + 0.5f);
} else {
error (command, Strutil::format ("Unrecognized geometry \"%s\"", geom));
return false;
}
// printf ("geom %dx%d, %+d%+d\n", w, h, x, y);
return true;
}
bool
OiioTool::set_attribute (ImageRecRef img, const std::string &attribname,
TypeDesc type, const std::string &value)
{
ot.read (img);
img->metadata_modified (true);
if (! value.length()) {
// If the value is the empty string, clear the attribute
return apply_spec_mod (*img, do_erase_attribute,
attribname, ot.allsubimages);
}
// Does it seem to be an int, or did the caller explicitly request
// that it be set as an int?
char *p = NULL;
int i = strtol (value.c_str(), &p, 10);
while (*p && isspace(*p))
++p;
if ((! *p && type == TypeDesc::UNKNOWN) || type == TypeDesc::INT) {
// int conversion succeeded and accounted for the whole string --
// so set an int attribute.
return apply_spec_mod (*img, do_set_any_attribute<int>,
std::pair<std::string,int>(attribname,i),
ot.allsubimages);
}
// Does it seem to be a float, or did the caller explicitly request
// that it be set as a float?
p = NULL;
float f = (float)strtod (value.c_str(), &p);
while (*p && isspace(*p))
++p;
if ((! *p && type == TypeDesc::UNKNOWN) || type == TypeDesc::FLOAT) {
// float conversion succeeded and accounted for the whole string --
// so set a float attribute.
return apply_spec_mod (*img, do_set_any_attribute<float>,
std::pair<std::string,float>(attribname,f),
ot.allsubimages);
}
// Otherwise, set it as a string attribute
return apply_spec_mod (*img, do_set_any_attribute<std::string>,
std::pair<std::string,std::string>(attribname,value),
ot.allsubimages);
}
static int
set_caption (int argc, const char *argv[])
{
ASSERT (argc == 2);
const char *newargs[3];
newargs[0] = argv[0];
newargs[1] = "ImageDescription";
newargs[2] = argv[1];
return set_string_attribute (3, newargs);
}
static bool
do_set_keyword (ImageSpec &spec, const std::string &keyword)
{
std::string oldkw = spec.get_string_attribute ("Keywords");
std::vector<std::string> oldkwlist;
if (! oldkw.empty())
Strutil::split (oldkw, oldkwlist, ";");
bool dup = false;
BOOST_FOREACH (std::string &ok, oldkwlist) {
ok = Strutil::strip (ok);
dup |= (ok == keyword);
}
if (! dup) {
oldkwlist.push_back (keyword);
spec.attribute ("Keywords", Strutil::join (oldkwlist, "; "));
}
return true;
}
static int
set_keyword (int argc, const char *argv[])
{
ASSERT (argc == 2);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
std::string keyword (argv[1]);
if (keyword.size())
apply_spec_mod (*ot.curimg, do_set_keyword, keyword, ot.allsubimages);
return 0;
}
static int
clear_keywords (int argc, const char *argv[])
{
ASSERT (argc == 1);
const char *newargs[3];
newargs[0] = argv[0];
newargs[1] = "Keywords";
newargs[2] = "";
return set_string_attribute (3, newargs);
}
static int
set_orientation (int argc, const char *argv[])
{
ASSERT (argc == 2);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
return set_attribute (ot.curimg, "Orientation", TypeDesc::INT, argv[1]);
}
static bool
do_rotate_orientation (ImageSpec &spec, string_view cmd)
{
bool rotcw = (cmd == "--orientcw" || cmd == "-orientcw" ||
cmd == "--rotcw" || cmd == "-rotcw");
bool rotccw = (cmd == "--orientccw" || cmd == "-orientccw" ||
cmd == "--rotccw" || cmd == "-rotccw");
bool rot180 = (cmd == "--orient180" || cmd == "-orient180" ||
cmd == "--rot180" || cmd == "-rot180");
int orientation = spec.get_int_attribute ("Orientation", 1);
if (orientation >= 1 && orientation <= 8) {
static int cw[] = { 0, 6, 7, 8, 5, 2, 3, 4, 1 };
if (rotcw || rotccw || rot180)
orientation = cw[orientation];
if (rotccw || rot180)
orientation = cw[orientation];
if (rotccw)
orientation = cw[orientation];
spec.attribute ("Orientation", orientation);
}
return true;
}
static int
rotate_orientation (int argc, const char *argv[])
{
ASSERT (argc == 1);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
apply_spec_mod (*ot.curimg, do_rotate_orientation, argv[0],
ot.allsubimages);
return 0;
}
static int
set_origin (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_origin, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
ImageSpec &spec (*A->spec(0,0));
int x = spec.x, y = spec.y, z = spec.z;
int w = spec.width, h = spec.height, d = spec.depth;
ot.adjust_geometry (argv[0], w, h, x, y, argv[1]);
if (spec.width != w || spec.height != h || spec.depth != d)
ot.warning (argv[0], "can't be used to change the size, only the origin");
if (spec.x != x || spec.y != y) {
ImageBuf &ib = (*A)(0,0);
if (ib.storage() == ImageBuf::IMAGECACHE) {
// If the image is cached, we will totally screw up the IB/IC
// operations if we try to change the origin in place, so in
// that case force a full read to convert to a local buffer,
// which is safe to diddle the origin.
ib.read (0, 0, true /*force*/, spec.format);
}
spec.x = x;
spec.y = y;
spec.z = z;
// That updated the private spec of the ImageRec. In this case
// we really need to update the underlying IB as well.
ImageSpec &ibspec = ib.specmod();
ibspec.x = x;
ibspec.y = y;
ibspec.z = z;
A->metadata_modified (true);
}
ot.function_times["origin"] += timer();
return 0;
}
static int
set_fullsize (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_fullsize, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
ImageSpec &spec (*A->spec(0,0));
int x = spec.full_x, y = spec.full_y;
int w = spec.full_width, h = spec.full_height;
ot.adjust_geometry (argv[0], w, h, x, y, argv[1]);
if (spec.full_x != x || spec.full_y != y ||
spec.full_width != w || spec.full_height != h) {
spec.full_x = x;
spec.full_y = y;
spec.full_width = w;
spec.full_height = h;
A->metadata_modified (true);
}
ot.function_times["fullsize"] += timer();
return 0;
}
static int
set_full_to_pixels (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_full_to_pixels, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
for (int s = 0, send = A->subimages(); s < send; ++s) {
for (int m = 0, mend = A->miplevels(s); m < mend; ++m) {
ImageSpec &spec = *A->spec(s,m);
spec.full_x = spec.x;
spec.full_y = spec.y;
spec.full_z = spec.z;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
// That updated the private spec of the ImageRec. In this case
// we really need to update the underlying IB as well.
ImageSpec &ibspec = (*A)(s,m).specmod();
ibspec.full_x = spec.x;
ibspec.full_y = spec.y;
ibspec.full_z = spec.z;
ibspec.full_width = spec.width;
ibspec.full_height = spec.height;
ibspec.full_depth = spec.depth;
}
}
A->metadata_modified (true);
ot.function_times["fullpixels"] += timer();
return 0;
}
static int
set_colorspace (int argc, const char *argv[])
{
ASSERT (argc == 2);
const char *args[3] = { argv[0], "oiio:ColorSpace", argv[1] };
return set_string_attribute (3, args);
}
static int
action_colorconvert (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (ot.postpone_callback (1, action_colorconvert, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string fromspace = argv[1];
std::string tospace = argv[2];
ot.read ();
bool need_transform = false;
ImageRecRef A = ot.curimg;
ot.read (A);
for (int s = 0, send = A->subimages(); s < send; ++s) {
for (int m = 0, mend = A->miplevels(s); m < mend; ++m) {
const ImageSpec *spec = A->spec(s,m);
need_transform |=
spec->get_string_attribute("oiio:ColorSpace") != tospace;
}
}
if (! need_transform)
return 1; // no need to do anything
ot.pop ();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s) {
for (int m = 0, mend = ot.curimg->miplevels(s); m < mend; ++m) {
bool ok = ImageBufAlgo::colorconvert ((*ot.curimg)(s,m), (*A)(s,m),
fromspace.c_str(), tospace.c_str(), false);
if (! ok)
ot.error (argv[0], (*ot.curimg)(s,m).geterror());
}
}
ot.function_times["colorconvert"] += timer();
return 1;
}
static int
action_tocolorspace (int argc, const char *argv[])
{
// Don't time -- let it get accounted by colorconvert
ASSERT (argc == 2);
if (! ot.curimg.get()) {
ot.warning (argv[0], "no current image available to modify");
return 0;
}
const char *args[3] = { argv[0], "current", argv[1] };
return action_colorconvert (3, args);
}
static int
action_ociolook (int argc, const char *argv[])
{
ASSERT (argc == 2);
if (ot.postpone_callback (1, action_ociolook, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string lookname = argv[1];
std::map<std::string,std::string> options;
options["inverse"] = "0";
options["from"] = "current";
options["to"] = "current";
options["key"] = "";
options["value"] = "";
extract_options (options, argv[0]);
std::string fromspace = options["from"];
std::string tospace = options["to"];
std::string contextkey = options["key"];
std::string contextvalue = options["value"];
bool inverse = Strutil::from_string<int> (options["inverse"]) != 0;
ImageRecRef A = ot.curimg;
ot.read (A);
ot.pop ();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
0, true, true|false));
if (fromspace == "current" || fromspace == "")
fromspace = A->spec(0,0)->get_string_attribute ("oiio:Colorspace", "Linear");
if (tospace == "current" || tospace == "")
tospace = A->spec(0,0)->get_string_attribute ("oiio:Colorspace", "Linear");
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s) {
for (int m = 0, mend = ot.curimg->miplevels(s); m < mend; ++m) {
bool ok = ImageBufAlgo::ociolook (
(*ot.curimg)(s,m), (*A)(s,m),
lookname.c_str(), fromspace.c_str(), tospace.c_str(),
false, inverse,
contextkey.c_str(), contextvalue.c_str());
if (! ok)
ot.error (argv[0], (*ot.curimg)(s,m).geterror());
}
}
ot.function_times["ociolook"] += timer();
return 1;
}
static int
action_ociodisplay (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (ot.postpone_callback (1, action_ociodisplay, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string displayname = argv[1];
std::string viewname = argv[2];
// TODO: this would be useful, but I don't like the syntax
// if (displayname == "")
// displayname = ot.colorconfig.getDefaultDisplayName();
// if (viewname == "")
// viewname = ot.colorconfig.getDefaultViewName();
std::map<std::string,std::string> options;
options["from"] = "current";
options["key"] = "";
options["value"] = "";
extract_options (options, argv[0]);
std::string fromspace = options["from"];
std::string contextkey = options["key"];
std::string contextvalue = options["value"];
bool override_looks = options.find("looks") != options.end();
ImageRecRef A = ot.curimg;
ot.read (A);
ot.pop ();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
0, true, true|false));
if (fromspace == "current" || fromspace == "")
fromspace = A->spec(0,0)->get_string_attribute ("oiio:Colorspace", "Linear");
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s) {
for (int m = 0, mend = ot.curimg->miplevels(s); m < mend; ++m) {
bool ok = ImageBufAlgo::ociodisplay (
(*ot.curimg)(s,m), (*A)(s,m),
displayname.c_str(), viewname.c_str(),
fromspace.c_str(),
override_looks ? options["looks"].c_str() : 0, false,
contextkey.c_str(), contextvalue.c_str());
if (! ok)
ot.error (argv[0], (*ot.curimg)(s,m).geterror());
}
}
ot.function_times["ociodisplay"] += timer();
return 1;
}
static int
action_unpremult (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unpremult, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m)
ImageBufAlgo::unpremult ((*R)(s,m), (*R)(s,m));
ot.function_times["unpremult"] += timer();
return 0;
}
static int
action_premult (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_premult, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m)
ImageBufAlgo::premult ((*R)(s,m), (*R)(s,m));
ot.function_times["premult"] += timer();
return 0;
}
static int
output_tiles (int /*argc*/, const char *argv[])
{
// the ArgParse will have set the tile size, but we need this routine
// to clear the scanline flag
ot.output_scanline = false;
return 0;
}
static int
action_unmip (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unmip, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
bool mipmapped = false;
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s)
mipmapped |= (ot.curimg->miplevels(s) > 1);
if (! mipmapped) {
return 0; // --unmip on an unmipped image is a no-op
}
ImageRecRef newimg (new ImageRec (*ot.curimg, -1, 0, true, true));
ot.curimg = newimg;
ot.function_times["unmip"] += timer();
return 0;
}
static int
set_channelnames (int argc, const char *argv[])
{
if (ot.postpone_callback (1, set_channelnames, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.curimg;
ot.read (A);
std::vector<std::string> newchannelnames;
Strutil::split (argv[1], newchannelnames, ",");
for (int s = 0; s < A->subimages(); ++s) {
int miplevels = A->miplevels(s);
for (int m = 0; m < miplevels; ++m) {
ImageSpec *spec = &(*A)(s,m).specmod();
spec->channelnames.resize (spec->nchannels);
for (int c = 0; c < spec->nchannels; ++c) {
if (c < (int)newchannelnames.size() &&
newchannelnames[c].size()) {
std::string name = newchannelnames[c];
spec->channelnames[c] = name;
if (Strutil::iequals(name,"A") ||
Strutil::iends_with(name,".A") ||
Strutil::iequals(name,"Alpha") ||
Strutil::iends_with(name,".Alpha"))
spec->alpha_channel = c;
if (Strutil::iequals(name,"Z") ||
Strutil::iends_with(name,".Z") ||
Strutil::iequals(name,"Depth") ||
Strutil::iends_with(name,".Depth"))
spec->z_channel = c;
}
}
A->update_spec_from_imagebuf(s,m);
}
}
ot.function_times["chnames"] += timer();
return 0;
}
// For a given spec (which contains the channel names for an image), and
// a comma separated list of channels (e.g., "B,G,R,A"), compute the
// vector of integer indices for those channels (e.g., {2,1,0,3}).
// A channel may be a literal assignment (e.g., "=0.5"), or a literal
// assignment with channel naming (e.g., "Z=0.5").
// Return true for success, false for failure, including if any of the
// channels were not present in the image. Upon return, channels
// will be the indices of the source image channels to copy (-1 for
// channels that are not filled with source data), values will hold
// the value to fill un-sourced channels (defaulting to zero), and
// newchannelnames will be the name of renamed or non-default-named
// channels (defaulting to "" if no special name is needed).
static bool
decode_channel_set (const ImageSpec &spec, std::string chanlist,
std::vector<std::string> &newchannelnames,
std::vector<int> &channels, std::vector<float> &values)
{
channels.clear ();
while (chanlist.length()) {
// Extract the next channel name
size_t pos = chanlist.find_first_of(",");
std::string onechan (chanlist, 0, pos);
onechan = Strutil::strip (onechan);
if (pos == std::string::npos)
chanlist.clear();
else
chanlist = chanlist.substr (pos+1, std::string::npos);
// Find the index corresponding to that channel
newchannelnames.push_back (std::string());
float value = 0.0f;
int ch = -1;
for (int i = 0; i < spec.nchannels; ++i)
if (spec.channelnames[i] == onechan) { // name of a known channel?
ch = i;
break;
}
if (ch < 0) { // Didn't find a match? Try case-insensitive.
for (int i = 0; i < spec.nchannels; ++i)
if (Strutil::iequals (spec.channelnames[i], onechan)) {
ch = i;
break;
}
}
if (ch < 0 && onechan.length() &&
(isdigit(onechan[0]) || onechan[0] == '-'))
ch = atoi (onechan.c_str()); // numeric channel index
if (ch < 0 && onechan.length()) {
// Look for Either =val or name=val
size_t equal_pos = onechan.find ('=');
if (equal_pos != std::string::npos) {
value = (float) atof (onechan.c_str()+equal_pos+1);
onechan.erase (equal_pos);
newchannelnames.back() = onechan;
}
}
channels.push_back (ch);
values.push_back (value);
}
return true;
}
static int
action_channels (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_channels, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
std::string chanlist = argv[1];
if (chanlist == "RGB") // Fix common synonyms/mistakes
chanlist = "R,G,B";
else if (chanlist == "RGBA")
chanlist = "R,G,B,A";
// Decode the channel set, make the full list of ImageSpec's we'll
// need to describe the new ImageRec with the altered channels.
std::vector<int> allmiplevels;
std::vector<ImageSpec> allspecs;
for (int s = 0, subimages = ot.allsubimages ? A->subimages() : 1;
s < subimages; ++s) {
std::vector<std::string> newchannelnames;
std::vector<int> channels;
std::vector<float> values;
bool ok = decode_channel_set (*A->spec(s,0), chanlist,
newchannelnames, channels, values);
if (! ok) {
ot.error (argv[0], Strutil::format("Invalid or unknown channel selection \"%s\"", chanlist));
ot.push (A);
return 0;
}
int miplevels = ot.allsubimages ? A->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
for (int m = 0; m < miplevels; ++m) {
ImageSpec spec = *A->spec(s,m);
spec.nchannels = (int)newchannelnames.size();
spec.channelformats.clear();
spec.default_channel_names ();
allspecs.push_back (spec);
}
}
// Create the replacement ImageRec
ImageRecRef R (new ImageRec(A->name(), (int)allmiplevels.size(),
&allmiplevels[0], &allspecs[0]));
ot.push (R);
// Subimage by subimage, MIP level by MIP level, copy/shuffle the
// channels individually from the source image into the result.
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
std::vector<std::string> newchannelnames;
std::vector<int> channels;
std::vector<float> values;
decode_channel_set (*A->spec(s,0), chanlist, newchannelnames,
channels, values);
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
// Shuffle the indexed/named channels
bool ok = ImageBufAlgo::channels ((*R)(s,m), (*A)(s,m),
(int)channels.size(), &channels[0],
&values[0], &newchannelnames[0], false);
if (! ok)
ot.error ("channels", (*R)(s,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(s,m);
}
}
ot.function_times["channels"] += timer();
return 0;
}
static int
action_chappend (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_chappend, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
std::vector<int> allmiplevels;
for (int s = 0, subimages = ot.allsubimages ? A->subimages() : 1;
s < subimages; ++s) {
int miplevels = ot.allsubimages ? A->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
}
// Create the replacement ImageRec
ImageRecRef R (new ImageRec(A->name(), (int)allmiplevels.size(),
&allmiplevels[0]));
ot.push (R);
// Subimage by subimage, MIP level by MIP level, channel_append the
// two images.
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
// Shuffle the indexed/named channels
bool ok = ImageBufAlgo::channel_append ((*R)(s,m), (*A)(s,m), (*B)(s,m));
if (! ok)
ot.error ("chappend", (*R)(s,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(s,m);
}
}
ot.function_times["chappend"] += timer();
return 0;
}
static int
action_selectmip (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_selectmip, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
bool mipmapped = false;
for (int s = 0, send = ot.curimg->subimages(); s < send; ++s)
mipmapped |= (ot.curimg->miplevels(s) > 1);
if (! mipmapped) {
return 0; // --selectmip on an unmipped image is a no-op
}
ImageRecRef newimg (new ImageRec (*ot.curimg, -1, atoi(argv[1]), true, true));
ot.curimg = newimg;
ot.function_times["selectmip"] += timer();
return 0;
}
static int
action_select_subimage (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_select_subimage, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
int subimage = atoi(argv[1]);
if (subimage < 0 || subimage >= ot.curimg->subimages()) {
ot.error ("-subimage",
Strutil::format ("Invalid -subimage (%d): %s has %d subimage%s",
subimage, ot.curimg->name(), ot.curimg->subimages(),
ot.curimg->subimages() == 1 ? "" : "s"));
return 0;
}
if (ot.curimg->subimages() == 1)
return 0; // --subimage on a single-image file is a no-op
ImageRecRef A = ot.pop();
ot.push (new ImageRec (*A, subimage));
ot.function_times["subimage"] += timer();
return 0;
}
static int
action_subimage_append (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_subimage_append, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
// Find the MIP levels in all the subimages of both A and B
std::vector<int> allmiplevels;
for (int s = 0; s < A->subimages(); ++s) {
int miplevels = ot.allsubimages ? A->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
}
for (int s = 0; s < B->subimages(); ++s) {
int miplevels = ot.allsubimages ? B->miplevels(s) : 1;
allmiplevels.push_back (miplevels);
}
// Create the replacement ImageRec
ImageRecRef R (new ImageRec(A->name(), (int)allmiplevels.size(),
&allmiplevels[0]));
ot.push (R);
// Subimage by subimage, MIP level by MIP level, copy
int sub = 0;
for (int s = 0; s < A->subimages(); ++s, ++sub) {
for (int m = 0; m < A->miplevels(s); ++m) {
bool ok = (*R)(sub,m).copy ((*A)(s,m));
if (! ok)
ot.error ("siappend", (*R)(sub,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(sub,m);
}
}
for (int s = 0; s < B->subimages(); ++s, ++sub) {
for (int m = 0; m < B->miplevels(s); ++m) {
bool ok = (*R)(sub,m).copy ((*B)(s,m));
if (! ok)
ot.error ("siappend", (*R)(sub,m).geterror());
// Tricky subtlety: IBA::channels changed the underlying IB,
// we may need to update the IRR's copy of the spec.
R->update_spec_from_imagebuf(sub,m);
}
}
ot.function_times["siappend"] += timer();
return 0;
}
static int
action_colorcount (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_colorcount, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageBuf &Aib ((*ot.curimg)(0,0));
int nchannels = Aib.nchannels();
// We assume ';' to split, but for the sake of some command shells,
// that use ';' as a command separator, also accept ":".
std::vector<float> colorvalues;
std::vector<std::string> colorstrings;
if (strchr (argv[1], ':'))
Strutil::split (argv[1], colorstrings, ":");
else
Strutil::split (argv[1], colorstrings, ";");
int ncolors = (int) colorstrings.size();
for (int col = 0; col < ncolors; ++col) {
std::vector<float> color (nchannels, 0.0f);
Strutil::extract_from_list_string (color, colorstrings[col], ",");
for (int c = 0; c < nchannels; ++c)
colorvalues.push_back (c < (int)color.size() ? color[c] : 0.0f);
}
std::vector<float> eps (nchannels, 0.001f);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
Strutil::extract_from_list_string (eps, options["eps"]);
imagesize_t *count = ALLOCA (imagesize_t, ncolors);
bool ok = ImageBufAlgo::color_count ((*ot.curimg)(0,0), count,
ncolors, &colorvalues[0], &eps[0]);
if (ok) {
for (int col = 0; col < ncolors; ++col)
std::cout << Strutil::format("%8d %s\n", count[col], colorstrings[col]);
} else {
ot.error ("colorcount", (*ot.curimg)(0,0).geterror());
}
ot.function_times["colorcount"] += timer();
return 0;
}
static int
action_rangecheck (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rangecheck, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageBuf &Aib ((*ot.curimg)(0,0));
int nchannels = Aib.nchannels();
std::vector<float> low(nchannels,0.0f), high(nchannels,1.0f);
Strutil::extract_from_list_string (low, argv[1], ",");
Strutil::extract_from_list_string (high, argv[2], ",");
imagesize_t lowcount = 0, highcount = 0, inrangecount = 0;
bool ok = ImageBufAlgo::color_range_check ((*ot.curimg)(0,0), &lowcount,
&highcount, &inrangecount,
&low[0], &high[0]);
if (ok) {
std::cout << Strutil::format("%8d < %s\n", lowcount, argv[1]);
std::cout << Strutil::format("%8d > %s\n", highcount, argv[2]);
std::cout << Strutil::format("%8d within range\n", inrangecount);
} else {
ot.error ("rangecheck", (*ot.curimg)(0,0).geterror());
}
ot.function_times["rangecheck"] += timer();
return 0;
}
static int
action_diff (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_diff, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int ret = do_action_diff (*ot.image_stack.back(), *ot.curimg, ot);
if (ret != DiffErrOK && ret != DiffErrWarn)
ot.return_value = EXIT_FAILURE;
if (ret != DiffErrOK && ret != DiffErrWarn && ret != DiffErrFail)
ot.error ("Error doing --diff");
ot.function_times["diff"] += timer();
return 0;
}
static int
action_pdiff (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_pdiff, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int ret = do_action_diff (*ot.image_stack.back(), *ot.curimg, ot, 1);
if (ret != DiffErrOK && ret != DiffErrWarn)
ot.return_value = EXIT_FAILURE;
if (ret != DiffErrOK && ret != DiffErrWarn && ret != DiffErrFail)
ot.error ("Error doing %s", argv[0]);
ot.function_times["pdiff"] += timer();
return 0;
}
static int
action_add (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_add, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
ImageRecRef R (new ImageRec (*A, *B, ot.allsubimages ? -1 : 0,
ImageRec::WinMergeUnion,
ImageRec::WinMergeUnion, TypeDesc::FLOAT));
ot.push (R);
int subimages = R->subimages();
for (int s = 0; s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
const ImageBuf &Bib ((*B)(s));
bool ok = ImageBufAlgo::add (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
ot.function_times["add"] += timer();
return 0;
}
static int
action_sub (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_sub, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
ImageRecRef R (new ImageRec (*A, *B, ot.allsubimages ? -1 : 0,
ImageRec::WinMergeUnion,
ImageRec::WinMergeUnion, TypeDesc::FLOAT));
ot.push (R);
int subimages = R->subimages();
for (int s = 0; s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
const ImageBuf &Bib ((*B)(s));
bool ok = ImageBufAlgo::sub (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
ot.function_times["sub"] += timer();
return 0;
}
static int
action_mul (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_mul, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
ImageRecRef R (new ImageRec (*A, *B, ot.allsubimages ? -1 : 0,
ImageRec::WinMergeUnion,
ImageRec::WinMergeUnion, TypeDesc::FLOAT));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
const ImageBuf &Bib ((*B)(s));
bool ok = ImageBufAlgo::mul (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
ot.function_times["mul"] += timer();
return 0;
}
static int
action_abs (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_abs, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int miplevels = ot.curimg->miplevels(s);
for (int m = 0; m < miplevels; ++m) {
const ImageBuf &Aib ((*A)(s,m));
ImageBuf &Rib ((*ot.curimg)(s,m));
ImageBuf::ConstIterator<float> a (Aib);
ImageBuf::Iterator<float> r (Rib);
int nchans = Rib.nchannels();
for ( ; ! r.done(); ++r) {
a.pos (r.x(), r.y());
for (int c = 0; c < nchans; ++c)
r[c] = fabsf(a[c]);
}
}
}
ot.function_times["abs"] += timer();
return 0;
}
static int
action_cmul (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cmul, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::vector<std::string> scalestrings;
Strutil::split (std::string(argv[1]), scalestrings, ",");
if (scalestrings.size() < 1)
return 0; // Implicit multiplication by 1 if we can't figure it out
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
std::vector<float> scale;
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int nchans = R->spec(s,0)->nchannels;
scale.clear ();
scale.resize (nchans, (float) atof(scalestrings[0].c_str()));
if (scalestrings.size() > 1) {
for (int c = 0; c < nchans; ++c) {
if (c < (int)scalestrings.size())
scale[c] = (float) atof(scalestrings[c].c_str());
else
scale[c] = 1.0f;
}
}
for (int m = 0, miplevels = ot.curimg->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::mul ((*R)(s,m), (*R)(s,m), &scale[0]);
if (! ok)
ot.error ("cmul", (*R)(s,m).geterror());
}
}
ot.function_times["cmul"] += timer();
return 0;
}
static int
action_cadd (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cadd, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::vector<std::string> addstrings;
Strutil::split (std::string(argv[1]), addstrings, ",");
if (addstrings.size() < 1)
return 0; // Implicit addition by 0 if we can't figure it out
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
std::vector<float> val;
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int nchans = R->spec(s,0)->nchannels;
val.clear ();
val.resize (nchans, (float) atof(addstrings[0].c_str()));
if (addstrings.size() > 1) {
for (int c = 0; c < nchans; ++c) {
if (c < (int)addstrings.size())
val[c] = (float) atof(addstrings[c].c_str());
else
val[c] = 0.0f;
}
}
for (int m = 0, miplevels = ot.curimg->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::add ((*R)(s,m), (*R)(s,m), &val[0]);
if (! ok)
ot.error ("cadd", (*R)(s,m).geterror());
}
}
ot.function_times["cadd"] += timer();
return 0;
}
static int
action_cpow (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cpow, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::vector<std::string> scalestrings;
Strutil::split (std::string(argv[1]), scalestrings, ",");
if (scalestrings.size() < 1)
return 0; // Implicit multiplication by 1 if we can't figure it out
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, true /*copy_pixels*/));
ot.push (R);
std::vector<float> scale;
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int nchans = R->spec(s,0)->nchannels;
scale.clear ();
scale.resize (nchans, (float) atof(scalestrings[0].c_str()));
if (scalestrings.size() > 1) {
for (int c = 0; c < nchans; ++c) {
if (c < (int)scalestrings.size())
scale[c] = (float) atof(scalestrings[c].c_str());
else
scale[c] = 1.0f;
}
}
for (int m = 0, miplevels = ot.curimg->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::pow ((*R)(s,m), (*R)(s,m), &scale[0]);
if (! ok)
ot.error ("cpow", (*R)(s,m).geterror());
}
}
ot.function_times["cpow"] += timer();
return 0;
}
static int
action_chsum (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_chsum, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("chsum", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
std::vector<float> weight ((*A)(s).nchannels(), 1.0f);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
Strutil::extract_from_list_string (weight, options["weight"]);
ImageBuf &Rib ((*R)(s));
const ImageBuf &Aib ((*A)(s));
bool ok = ImageBufAlgo::channel_sum (Rib, Aib, &weight[0]);
if (! ok)
ot.error ("chsum", Rib.geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["chsum"] += timer();
return 0;
}
static int
action_flip (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_flip, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("flip", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::flip ((*R)(s), (*A)(s));
if (! ok)
ot.error ("flip", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["flip"] += timer();
return 0;
}
static int
action_flop (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_flop, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("flop", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::flop ((*R)(s), (*A)(s));
if (! ok)
ot.error ("flop", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["flop"] += timer();
return 0;
}
static int
action_rotate180 (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate180, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("rotate180", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::rotate180 ((*R)(s), (*A)(s));
if (! ok)
ot.error ("rotate180", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate180"] += timer();
return 0;
}
static int
action_rotate90 (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate90, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("rotate90", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::rotate90 ((*R)(s), (*A)(s));
if (! ok)
ot.error ("rotate90", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate90"] += timer();
return 0;
}
static int
action_rotate270 (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate270, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
ot.read (A);
ImageRecRef R (new ImageRec ("rotate270", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::rotate270 ((*R)(s), (*A)(s));
if (! ok)
ot.error ("rotate270", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate270"] += timer();
return 0;
}
int
action_reorient (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_reorient, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Make sure time in the rotate functions is charged to reorient
bool old_enable_function_timing = ot.enable_function_timing;
ot.enable_function_timing = false;
ImageRecRef A = ot.pop();
ot.read (A);
// See if any subimages need to be reoriented
bool needs_reorient = false;
for (int s = 0, subimages = A->subimages(); s < subimages; ++s) {
int orientation = (*A)(s).orientation();
needs_reorient |= (orientation != 1);
}
if (needs_reorient) {
ImageRecRef R (new ImageRec ("reorient", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBufAlgo::reorient ((*R)(s), (*A)(s));
R->update_spec_from_imagebuf (s);
}
} else {
// No subimages need modification, just leave the whole thing in
// place.
ot.push (A);
}
ot.function_times["reorient"] += timer();
ot.enable_function_timing = old_enable_function_timing;
return 0;
}
static int
action_transpose (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_transpose, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("transpose",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::transpose ((*R)(s), (*A)(s));
if (! ok)
ot.error ("transpose", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["transpose"] += timer();
return 0;
}
static int
action_rotate (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rotate, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string filtername = options["filter"];
bool recompute_roi = Strutil::from_string<int>(options["recompute_roi"]);
bool center_supplied = false;
std::string center = options["center"];
float center_x = 0.0f, center_y = 0.0f;
if (center.size()) {
string_view s (center);
if (Strutil::parse_float (s, center_x) &&
Strutil::parse_char (s, ',') &&
Strutil::parse_float (s, center_y)) {
center_supplied = true;
}
}
float angle = Strutil::from_string<float> (argv[1]);
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("rotate",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
float cx, cy;
if (center_supplied) {
cx = center_x;
cy = center_y;
} else {
ROI src_roi_full = (*A)(s).roi_full();
cx = 0.5f * (src_roi_full.xbegin + src_roi_full.xend);
cy = 0.5f * (src_roi_full.ybegin + src_roi_full.yend);
}
bool ok = ImageBufAlgo::rotate ((*R)(s), (*A)(s),
angle*float(M_PI/180.0), cx, cy,
filtername, 0.0f, recompute_roi);
if (! ok)
ot.error ("rotate", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["rotate"] += timer();
return 0;
}
static int
action_warp (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_warp, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string filtername = options["filter"];
bool recompute_roi = Strutil::from_string<int>(options["recompute_roi"]);
std::vector<float> M (9);
if (Strutil::extract_from_list_string (M, argv[1]) != 9) {
ot.error ("warp", "expected 9 comma-separatd floats to form a 3x3 matrix");
return 0;
}
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("warp",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::warp ((*R)(s), (*A)(s),
*(Imath::M33f *)&M[0],
filtername, 0.0f,
recompute_roi, ImageBuf::WrapDefault);
if (! ok)
ot.error ("warp", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["warp"] += timer();
return 0;
}
static int
action_cshift (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cshift, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int x = 0, y = 0, z = 0;
if (sscanf (argv[1], "%d%d%d", &x, &y, &z) < 2) {
ot.error ("cshift", Strutil::format ("Invalid shift offset '%s'", argv[1]));
return 0;
}
ImageRecRef A (ot.pop());
ot.read (A);
ImageRecRef R (new ImageRec ("cshift",
ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
bool ok = ImageBufAlgo::circular_shift ((*R)(s), (*A)(s), x, y, z);
if (! ok)
ot.error ("cshift", (*R)(s).geterror());
R->update_spec_from_imagebuf (s);
}
ot.function_times["cshift"] += timer();
return 0;
}
static int
action_pop (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.pop ();
return 0;
}
static int
action_dup (int argc, const char *argv[])
{
ASSERT (argc == 1);
ot.push (ot.curimg);
return 0;
}
static int
action_swap (int argc, const char *argv[])
{
ASSERT (argc == 1);
if (ot.image_stack.size() < 1) {
ot.error (argv[0], "requires at least two loaded images");
return 0;
}
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.push (B);
ot.push (A);
return 0;
}
static int
action_create (int argc, const char *argv[])
{
ASSERT (argc == 3);
Timer timer (ot.enable_function_timing);
int nchans = atoi (argv[2]);
if (nchans < 1 || nchans > 1024) {
ot.warning (argv[0], Strutil::format ("Invalid number of channels: %d", nchans));
nchans = 3;
}
ImageSpec spec (64, 64, nchans, TypeDesc::FLOAT);
ot.adjust_geometry (argv[0], spec.width, spec.height, spec.x, spec.y, argv[1]);
spec.full_x = spec.x;
spec.full_y = spec.y;
spec.full_z = spec.z;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
ImageRecRef img (new ImageRec ("new", spec, ot.imagecache));
bool ok = ImageBufAlgo::zero ((*img)());
if (! ok)
ot.error (argv[0], (*img)().geterror());
if (ot.curimg)
ot.image_stack.push_back (ot.curimg);
ot.curimg = img;
ot.function_times["create"] += timer();
return 0;
}
static int
action_pattern (int argc, const char *argv[])
{
ASSERT (argc == 4);
Timer timer (ot.enable_function_timing);
int nchans = atoi (argv[3]);
if (nchans < 1 || nchans > 1024) {
ot.warning (argv[0], Strutil::format ("Invalid number of channels: %d", nchans));
nchans = 3;
}
ImageSpec spec (64, 64, nchans, TypeDesc::FLOAT);
ot.adjust_geometry (argv[0], spec.width, spec.height, spec.x, spec.y, argv[2]);
spec.full_x = spec.x;
spec.full_y = spec.y;
spec.full_z = spec.z;
spec.full_width = spec.width;
spec.full_height = spec.height;
spec.full_depth = spec.depth;
ImageRecRef img (new ImageRec ("new", spec, ot.imagecache));
ImageBuf &ib ((*img)());
std::string pattern = argv[1];
if (Strutil::iequals(pattern,"black")) {
bool ok = ImageBufAlgo::zero (ib);
if (! ok)
ot.error (argv[0], ib.geterror());
} else if (Strutil::istarts_with(pattern,"constant")) {
std::vector<float> fill (nchans, 1.0f);
std::map<std::string,std::string> options;
extract_options (options, pattern);
Strutil::extract_from_list_string (fill, options["color"]);
bool ok = ImageBufAlgo::fill (ib, &fill[0]);
if (! ok)
ot.error (argv[0], ib.geterror());
} else if (Strutil::istarts_with(pattern,"checker")) {
std::map<std::string,std::string> options;
options["width"] = "8";
options["height"] = "8";
options["depth"] = "8";
extract_options (options, pattern);
int width = Strutil::from_string<int> (options["width"]);
int height = Strutil::from_string<int> (options["height"]);
int depth = Strutil::from_string<int> (options["depth"]);
std::vector<float> color1 (nchans, 0.0f);
std::vector<float> color2 (nchans, 1.0f);
Strutil::extract_from_list_string (color1, options["color1"]);
Strutil::extract_from_list_string (color2, options["color2"]);
bool ok = ImageBufAlgo::checker (ib, width, height, depth,
&color1[0], &color2[0], 0, 0, 0);
if (! ok)
ot.error (argv[0], ib.geterror());
} else {
bool ok = ImageBufAlgo::zero (ib);
if (! ok)
ot.error (argv[0], ib.geterror());
}
ot.push (img);
ot.function_times["pattern"] += timer();
return 0;
}
static int
action_kernel (int argc, const char *argv[])
{
ASSERT (argc == 3);
Timer timer (ot.enable_function_timing);
int nchans = 1;
if (nchans < 1 || nchans > 1024) {
ot.warning (argv[0], Strutil::format ("Invalid number of channels: %d", nchans));
nchans = 3;
}
float w = 1.0f, h = 1.0f;
if (sscanf (argv[2], "%fx%f", &w, &h) != 2)
ot.error ("kernel", Strutil::format ("Unknown size %s", argv[2]));
ImageSpec spec (1, 1, nchans, TypeDesc::FLOAT);
ImageRecRef img (new ImageRec ("kernel", spec, ot.imagecache));
ImageBuf &ib ((*img)());
int ok = ImageBufAlgo::make_kernel (ib, argv[1], w, h);
if (! ok)
ot.error (argv[0], ib.geterror());
img->update_spec_from_imagebuf (0, 0);
ot.push (img);
ot.function_times["kernel"] += timer();
return 0;
}
static int
action_capture (int argc, const char *argv[])
{
ASSERT (argc == 1);
Timer timer (ot.enable_function_timing);
int camera = 0;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(cmd,"camera="))
camera = atoi(cmd.c_str()+7);
}
ImageBuf ib;
bool ok = ImageBufAlgo::capture_image (ib, camera, TypeDesc::FLOAT);
if (! ok)
ot.error (argv[0], ib.geterror());
ImageRecRef img (new ImageRec ("capture", ib.spec(), ot.imagecache));
(*img)().copy (ib);
ot.push (img);
ot.function_times["capture"] += timer();
return 0;
}
int
action_crop (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_crop, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1]);
if (newspec.width != Aspec.width || newspec.height != Aspec.height) {
// resolution changed -- we need to do a full crop
ot.pop();
ot.push (new ImageRec (A->name(), newspec, ot.imagecache));
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*ot.curimg)(0,0));
bool ok = ImageBufAlgo::crop (Rib, Aib, get_roi(newspec));
if (! ok)
ot.error (argv[0], Rib.geterror());
} else if (newspec.x != Aspec.x || newspec.y != Aspec.y) {
// only offset changed; don't copy the image or crop, simply
// adjust the origins.
Aspec.x = newspec.x;
Aspec.y = newspec.y;
A->metadata_modified (true);
}
ot.function_times["crop"] += timer();
return 0;
}
int
action_croptofull (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_croptofull, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.curimg;
const ImageSpec &Aspec (*A->spec(0,0));
// Implement by calling action_crop with a geometry specifier built
// from the current full image size.
std::string size = format_resolution (Aspec.full_width, Aspec.full_height,
Aspec.full_x, Aspec.full_y);
const char *newargv[2] = { "crop", size.c_str() };
bool old_enable_function_timing = ot.enable_function_timing;
ot.enable_function_timing = false;
int result = action_crop (2, newargv);
ot.function_times["croptofull"] += timer();
ot.enable_function_timing = old_enable_function_timing;
return result;
}
int
action_cut (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_cut, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1]);
ImageRecRef R (new ImageRec (A->name(), newspec, ot.imagecache));
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*R)(0,0));
ImageBufAlgo::cut (Rib, Aib, get_roi(newspec));
ImageSpec &spec (*R->spec(0,0));
set_roi (spec, Rib.roi());
set_roi_full (spec, Rib.roi());
A->metadata_modified (true);
ot.push (R);
ot.function_times["cut"] += timer();
return 0;
}
static int
action_resample (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_resample, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
const ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1], true);
if (newspec.width == Aspec.width && newspec.height == Aspec.height) {
ot.push (A); // Restore the original image
return 0; // nothing to do
}
// Shrink-wrap full to match actual pixels; I'm not sure what else
// is appropriate, need to think it over.
newspec.full_x = newspec.x;
newspec.full_y = newspec.y;
newspec.full_width = newspec.width;
newspec.full_height = newspec.height;
ot.push (new ImageRec (A->name(), newspec, ot.imagecache));
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*ot.curimg)(0,0));
bool ok = ImageBufAlgo::resample (Rib, Aib);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["resample"] += timer();
return 0;
}
static int
action_resize (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_resize, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::string filtername;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (! strncmp (cmd.c_str(), "filter=", 7)) {
filtername = cmd.substr (7, std::string::npos);
}
}
ot.read ();
ImageRecRef A = ot.pop();
const ImageSpec &Aspec (*A->spec(0,0));
ImageSpec newspec = Aspec;
ot.adjust_geometry (argv[0], newspec.width, newspec.height,
newspec.x, newspec.y, argv[1], true);
if (newspec.width == Aspec.width && newspec.height == Aspec.height) {
ot.push (A); // Restore the original image
return 0; // nothing to do
}
// Shrink-wrap full to match actual pixels; I'm not sure what else
// is appropriate, need to think it over.
newspec.full_x = newspec.x;
newspec.full_y = newspec.y;
newspec.full_width = newspec.width;
newspec.full_height = newspec.height;
ot.push (new ImageRec (A->name(), newspec, ot.imagecache));
if (ot.verbose) {
std::cout << "Resizing " << Aspec.width << "x" << Aspec.height
<< " to " << newspec.width << "x" << newspec.height
<< " using "
<< (filtername.size() ? filtername.c_str() : "default")
<< " filter\n";
}
const ImageBuf &Aib ((*A)(0,0));
ImageBuf &Rib ((*ot.curimg)(0,0));
bool ok = ImageBufAlgo::resize (Rib, Aib, filtername, 0.0f, get_roi(Rib.spec()));
ot.function_times["resize"] += timer();
if (! ok)
ot.error (argv[0], Rib.geterror());
return 0;
}
static int
action_fit (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fit, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
bool old_enable_function_timing = ot.enable_function_timing;
ot.enable_function_timing = false;
// Examine the top of stack
ImageRecRef A = ot.top();
ot.read ();
const ImageSpec *Aspec = A->spec(0,0);
// Parse the user request for resolution to fit
int fit_full_width = Aspec->full_width;
int fit_full_height = Aspec->full_height;
int fit_full_x = Aspec->full_x;
int fit_full_y = Aspec->full_y;
ot.adjust_geometry (argv[0], fit_full_width, fit_full_height,
fit_full_x, fit_full_y, argv[1], false);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string padopt = options["pad"];
bool pad = padopt.size() && atoi(padopt.c_str());
std::string filtername = options["filter"];
// Compute scaling factors and use action_resize to do the heavy lifting
float oldaspect = float(Aspec->full_width) / Aspec->full_height;
float newaspect = float(fit_full_width) / fit_full_height;
int resize_full_width = fit_full_width;
int resize_full_height = fit_full_height;
int xoffset = 0, yoffset = 0;
if (newaspect >= oldaspect) { // same or wider than original
resize_full_width = int(resize_full_height * oldaspect + 0.5f);
xoffset = (fit_full_width - resize_full_width) / 2;
} else { // narrower than original
resize_full_height = int(resize_full_width / oldaspect + 0.5f);
yoffset = (fit_full_height - resize_full_height) / 2;
}
if (ot.verbose) {
std::cout << "Fitting "
<< format_resolution(Aspec->full_width, Aspec->full_height,
Aspec->full_x, Aspec->full_y)
<< " into "
<< format_resolution(fit_full_width, fit_full_height,
fit_full_x, fit_full_y)
<< "\n";
std::cout << " Resizing to "
<< format_resolution(resize_full_width, resize_full_height,
fit_full_x, fit_full_y) << "\n";
}
if (resize_full_width != Aspec->full_width ||
resize_full_height != Aspec->full_height ||
fit_full_x != Aspec->full_x || fit_full_y != Aspec->full_y) {
std::string resize = format_resolution (resize_full_width,
resize_full_height,
0, 0);
std::string command = "resize";
if (filtername.size())
command += Strutil::format (":filter=%s", filtername);
const char *newargv[2] = { command.c_str(), resize.c_str() };
action_resize (2, newargv);
A = ot.top ();
Aspec = A->spec(0,0);
A->spec(0,0)->full_width = (*A)(0,0).specmod().full_width = fit_full_width;
A->spec(0,0)->full_height = (*A)(0,0).specmod().full_height = fit_full_height;
A->spec(0,0)->full_x = (*A)(0,0).specmod().full_x = fit_full_x;
A->spec(0,0)->full_y = (*A)(0,0).specmod().full_y = fit_full_y;
A->spec(0,0)->x = (*A)(0,0).specmod().x = xoffset;
A->spec(0,0)->y = (*A)(0,0).specmod().y = yoffset;
// Now A,Aspec are for the NEW resized top of stack
}
if (pad && (fit_full_width != Aspec->width ||
fit_full_height != Aspec->height)) {
// Needs padding
const char *argv[] = { "croptofull" };
action_croptofull (1, argv);
}
ot.function_times["fit"] += timer();
ot.enable_function_timing = old_enable_function_timing;
return 0;
}
static int
action_convolve (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_convolve, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef K = ot.pop(); // kernel
ImageRecRef A = ot.pop();
A->read();
K->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::convolve (Rib, (*A)(s), (*K)(0));
if (! ok)
ot.error ("convolve", Rib.geterror());
}
ot.function_times["convolve"] += timer();
return 0;
}
static int
action_blur (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_blur, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
options["kernel"] = "gaussian";
extract_options (options, argv[0]);
std::string kernopt = options["kernel"];
float w = 1.0f, h = 1.0f;
if (sscanf (argv[1], "%fx%f", &w, &h) != 2)
ot.error ("blur", Strutil::format ("Unknown size %s", argv[1]));
ImageBuf Kernel ("kernel");
if (! ImageBufAlgo::make_kernel (Kernel, kernopt.c_str(), w, h))
ot.error ("blur", Kernel.geterror());
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::convolve (Rib, (*A)(s), Kernel);
if (! ok)
ot.error ("blur", Rib.geterror());
}
ot.function_times["blur"] += timer();
return 0;
}
static int
action_median (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_median, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int w = 3, h = 3;
if (sscanf (argv[1], "%dx%d", &w, &h) != 2)
ot.error ("median", Strutil::format ("Unknown size %s", argv[1]));
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::median_filter (Rib, (*A)(s), w, h);
if (! ok)
ot.error ("median", Rib.geterror());
}
ot.function_times["median"] += timer();
return 0;
}
static int
action_unsharp (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unsharp, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
options["kernel"] = "gaussian";
options["width"] = "3";
options["contrast"] = "1";
options["threshold"] = "0";
extract_options (options, argv[0]);
std::string kernel = options["kernel"];
float width = Strutil::from_string<float> (options["width"]);
float contrast = Strutil::from_string<float> (options["contrast"]);
float threshold = Strutil::from_string<float> (options["threshold"]);
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0, 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::unsharp_mask (Rib, (*A)(s), kernel.c_str(),
width, contrast, threshold);
if (! ok)
ot.error ("unsharp", Rib.geterror());
}
ot.function_times["unsharp"] += timer();
return 0;
}
static int
action_fft (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fft, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec ("fft", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::fft (Rib, (*A)(s));
R->update_spec_from_imagebuf (s);
if (! ok)
ot.error ("fft", Rib.geterror());
}
ot.function_times["fft"] += timer();
return 0;
}
static int
action_ifft (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_ifft, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read();
ImageRecRef R (new ImageRec ("ifft", ot.allsubimages ? A->subimages() : 1));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
ImageBuf &Rib ((*R)(s));
bool ok = ImageBufAlgo::ifft (Rib, (*A)(s));
R->update_spec_from_imagebuf (s);
if (! ok)
ot.error ("ifft", Rib.geterror());
}
ot.function_times["ifft"] += timer();
return 0;
}
static int
action_polar (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_polar, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::complex_to_polar ((*R)(s,m), (*A)(s,m));
if (! ok)
ot.error ("polar", (*R)(s,m).geterror());
}
ot.function_times["polar"] += timer();
return 0;
}
static int
action_unpolar (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_unpolar, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ot.read ();
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s)
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::polar_to_complex ((*R)(s,m), (*A)(s,m));
if (! ok)
ot.error ("unpolar", (*R)(s,m).geterror());
}
ot.function_times["unpolar"] += timer();
return 0;
}
int
action_fixnan (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fixnan, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
NonFiniteFixMode mode = NONFINITE_BOX3;
if (!strcmp(argv[1], "black"))
mode = NONFINITE_BLACK;
else if (!strcmp(argv[1], "box3"))
mode = NONFINITE_BOX3;
else {
ot.warning (argv[0], Strutil::format ("\"%s\" not recognized. Valid choices: black, box3.", argv[1]));
}
ot.read ();
ImageRecRef A = ot.pop();
ot.push (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0, true, false));
int subimages = ot.curimg->subimages();
for (int s = 0; s < subimages; ++s) {
int miplevels = ot.curimg->miplevels(s);
for (int m = 0; m < miplevels; ++m) {
const ImageBuf &Aib ((*A)(s,m));
ImageBuf &Rib ((*ot.curimg)(s,m));
bool ok = ImageBufAlgo::fixNonFinite (Rib, Aib, mode);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
}
ot.function_times["fixnan"] += timer();
return 0;
}
static int
action_fillholes (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fillholes, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Read and copy the top-of-stack image
ImageRecRef A (ot.pop());
ot.read (A);
ImageSpec spec = (*A)(0,0).spec();
set_roi (spec, roi_union (get_roi(spec), get_roi_full(spec)));
ImageRecRef B (new ImageRec("filled", spec, ot.imagecache));
ot.push (B);
ImageBuf &Rib ((*B)(0,0));
bool ok = ImageBufAlgo::fillholes_pushpull (Rib, (*A)(0,0));
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["fillholes"] += timer();
return 0;
}
static int
action_paste (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_paste, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef BG (ot.pop());
ImageRecRef FG (ot.pop());
ot.read (BG);
ot.read (FG);
int x = 0, y = 0;
if (sscanf (argv[1], "%d%d", &x, &y) != 2) {
ot.error ("paste", Strutil::format ("Invalid offset '%s'", argv[1]));
return 0;
}
ImageRecRef R (new ImageRec (*BG, 0, 0, true /* writable*/, true /* copy */));
ot.push (R);
bool ok = ImageBufAlgo::paste ((*R)(), x, y, 0, 0, (*FG)());
if (! ok)
ot.error (argv[0], (*R)().geterror());
ot.function_times["paste"] += timer();
return 0;
}
static int
action_mosaic (int argc, const char *argv[])
{
// Mosaic is tricky. We have to parse the argument before we know
// how many images it wants to pull off the stack.
int ximages = 0, yimages = 0;
if (sscanf (argv[1], "%dx%d", &ximages, &yimages) != 2
|| ximages < 1 || yimages < 1) {
ot.error ("mosaic", Strutil::format ("Invalid size '%s'", argv[1]));
return 0;
}
int nimages = ximages * yimages;
if (ot.postpone_callback (nimages, action_paste, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
int widest = 0, highest = 0, nchannels = 0;
std::vector<ImageRecRef> images (nimages);
for (int i = nimages-1; i >= 0; --i) {
ImageRecRef img = ot.pop();
images[i] = img;
ot.read (img);
widest = std::max (widest, img->spec()->full_width);
highest = std::max (highest, img->spec()->full_height);
nchannels = std::max (nchannels, img->spec()->nchannels);
}
std::map<std::string,std::string> options;
options["pad"] = "0";
extract_options (options, argv[0]);
int pad = strtol (options["pad"].c_str(), NULL, 10);
ImageSpec Rspec (ximages*widest + (ximages-1)*pad,
yimages*highest + (yimages-1)*pad,
nchannels, TypeDesc::FLOAT);
ImageRecRef R (new ImageRec ("mosaic", Rspec, ot.imagecache));
ot.push (R);
ImageBufAlgo::zero ((*R)());
for (int j = 0; j < yimages; ++j) {
int y = j * (highest + pad);
for (int i = 0; i < ximages; ++i) {
int x = i * (widest + pad);
bool ok = ImageBufAlgo::paste ((*R)(), x, y, 0, 0,
(*images[j*ximages+i])(0));
if (! ok)
ot.error (argv[0], (*R)().geterror());
}
}
ot.function_times["mosaic"] += timer();
return 0;
}
static int
action_over (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_over, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
const ImageBuf &Aib ((*A)());
const ImageBuf &Bib ((*B)());
const ImageSpec &specA = Aib.spec();
const ImageSpec &specB = Bib.spec();
// Create output image specification.
ImageSpec specR = specA;
set_roi (specR, roi_union (get_roi(specA), get_roi(specB)));
set_roi_full (specR, roi_union (get_roi_full(specA), get_roi_full(specB)));
ot.push (new ImageRec ("over", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
bool ok = ImageBufAlgo::over (Rib, Aib, Bib);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["over"] += timer();
return 0;
}
static int
action_zover (int argc, const char *argv[])
{
if (ot.postpone_callback (2, action_zover, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Get optional flags
bool z_zeroisinf = false;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(cmd,"zeroisinf="))
z_zeroisinf = (atoi(cmd.c_str()+10) != 0);
}
ImageRecRef B (ot.pop());
ImageRecRef A (ot.pop());
ot.read (A);
ot.read (B);
const ImageBuf &Aib ((*A)());
const ImageBuf &Bib ((*B)());
const ImageSpec &specA = Aib.spec();
const ImageSpec &specB = Bib.spec();
// Create output image specification.
ImageSpec specR = specA;
set_roi (specR, roi_union (get_roi(specA), get_roi(specB)));
set_roi_full (specR, roi_union (get_roi_full(specA), get_roi_full(specB)));
ot.push (new ImageRec ("zover", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
bool ok = ImageBufAlgo::zover (Rib, Aib, Bib, z_zeroisinf);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["zover"] += timer();
return 0;
}
static int
action_flatten (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_flatten, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A (ot.pop());
ot.read (A);
const ImageBuf &Aib ((*A)());
const ImageSpec &specA = Aib.spec();
// Create output image specification.
ImageSpec specR = specA;
specR.deep = false;
ot.push (new ImageRec ("flatten", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
bool ok = ImageBufAlgo::flatten (Rib, Aib);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["flatten"] += timer();
return 0;
}
static int
action_fill (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_fill, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Read and copy the top-of-stack image
ImageRecRef A (ot.pop());
ot.read (A);
ot.push (new ImageRec (*A, 0, 0, true, true /*copy_pixels*/));
ImageBuf &Rib ((*ot.curimg)(0,0));
const ImageSpec &Rspec = Rib.spec();
int w = Rib.spec().width, h = Rib.spec().height;
int x = Rib.spec().x, y = Rib.spec().y;
if (! ot.adjust_geometry (argv[0], w, h, x, y, argv[1], true)) {
return 0;
}
float *color = ALLOCA (float, Rspec.nchannels);
for (int c = 0; c < Rspec.nchannels; ++c)
color[c] = 1.0f;
// Parse optional arguments for overrides
std::string command = argv[0];
size_t pos;
while ((pos = command.find_first_of(":")) != std::string::npos) {
command = command.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(command,"color=")) {
// Parse comma-separated color list
size_t numpos = 6;
for (int c = 0; c < Rspec.nchannels && numpos < command.size() && command[numpos] != ':'; ++c) {
color[c] = (float) atof (command.c_str()+numpos);
while (numpos < command.size() && command[numpos] != ':' && command[numpos] != ',')
++numpos;
if (numpos < command.size())
++numpos;
}
}
}
bool ok = ImageBufAlgo::fill (Rib, color, ROI(x, x+w, y, y+h));
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["fill"] += timer();
return 0;
}
static int
action_clamp (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_clamp, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
ImageRecRef A = ot.pop();
A->read ();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writeable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
int nchans = (*R)(s,0).nchannels();
const float big = std::numeric_limits<float>::max();
std::vector<float> min (nchans, -big);
std::vector<float> max (nchans, big);
std::map<std::string,std::string> options;
options["clampalpha"] = "0"; // initialize
extract_options (options, argv[0]);
Strutil::extract_from_list_string (min, options["min"]);
Strutil::extract_from_list_string (max, options["max"]);
bool clampalpha01 = strtol (options["clampalpha"].c_str(), NULL, 10) != 0;
for (int m = 0, miplevels=R->miplevels(s); m < miplevels; ++m) {
ImageBuf &Rib ((*R)(s,m));
ImageBuf &Aib ((*A)(s,m));
bool ok = ImageBufAlgo::clamp (Rib, Aib, &min[0], &max[0], clampalpha01);
if (! ok)
ot.error (argv[0], Rib.geterror());
}
}
ot.function_times["clamp"] += timer();
return 0;
}
static int
action_rangecompress (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rangecompress, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string useluma_str = options["luma"];
bool useluma = useluma_str.size() && atoi(useluma_str.c_str()) != 0;
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::rangecompress ((*R)(s,m), (*A)(s,m), useluma);
if (! ok)
ot.error (argv[0], (*R)(s,m).geterror());
}
}
ot.function_times["rangecompress"] += timer();
return 0;
}
static int
action_rangeexpand (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_rangeexpand, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
std::string useluma_str = options["luma"];
bool useluma = useluma_str.size() && atoi(useluma_str.c_str()) != 0;
ImageRecRef A = ot.pop();
ImageRecRef R (new ImageRec (*A, ot.allsubimages ? -1 : 0,
ot.allsubimages ? -1 : 0,
true /*writable*/, false /*copy_pixels*/));
ot.push (R);
for (int s = 0, subimages = R->subimages(); s < subimages; ++s) {
for (int m = 0, miplevels = R->miplevels(s); m < miplevels; ++m) {
bool ok = ImageBufAlgo::rangeexpand ((*R)(s,m), (*A)(s,m), useluma);
if (! ok)
ot.error (argv[0], (*R)(s,m).geterror());
}
}
ot.function_times["rangeexpand"] += timer();
return 0;
}
static int
action_text (int argc, const char *argv[])
{
if (ot.postpone_callback (1, action_text, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Read and copy the top-of-stack image
ImageRecRef A (ot.pop());
ot.read (A);
ot.push (new ImageRec (*A, 0, 0, true, true /*copy_pixels*/));
ImageBuf &Rib ((*ot.curimg)(0,0));
const ImageSpec &Rspec = Rib.spec();
// Set up defaults for text placement, size, font, color
std::map<std::string,std::string> options;
extract_options (options, argv[0]);
int x = options["x"].size() ? Strutil::from_string<int>(options["x"]) : (Rspec.x + Rspec.width/2);
int y = options["y"].size() ? Strutil::from_string<int>(options["y"]) : (Rspec.y + Rspec.height/2);
int fontsize = options["size"].size() ? Strutil::from_string<int>(options["size"]) : 16;
std::string font = options["font"];
std::vector<float> textcolor (Rspec.nchannels, 1.0f);
Strutil::extract_from_list_string (textcolor, options["color"]);
bool ok = ImageBufAlgo::render_text (Rib, x, y, argv[1] /* the text */,
fontsize, font, &textcolor[0]);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["text"] += timer();
return 0;
}
/// action_histogram ---------------------------------------------------------
/// Usage:
/// ./oiiotool in --histogram:cumulative=int 'bins'x'height'
/// channel -o out
///
/// in - Input image that contains the channel to be histogramed.
/// cumulative - Optional argument that can take values 0 or 1. If 0,
/// then each bin will contain the count of pixels having
/// values in the range for that bin. If 1, then each bin
/// will contain not only its count, but also the counts of
/// all preceding bins.
/// 'bins'x'height' - Width and height of the histogram, where width equals
/// the number of bins.
/// channel - The channel in the input image to be histogramed.
/// out - Output image.
///
/// Examples:
/// - ./oiiotool in --histogram 256x256 0 -o out
///
/// Save the non-cumulative histogram of channel 0 in image
/// 'in', as an image with size 256x256.
///
/// - ./oiiotool in --histogram:cumulative=1 256x256 0 -o out
///
/// Same as the previous example, but now a cumulative
/// histogram is created, instead of a regular one.
/// --------------------------------------------------------------------------
static int
action_histogram (int argc, const char *argv[])
{
ASSERT (argc == 3);
if (ot.postpone_callback (1, action_histogram, argc, argv))
return 0;
Timer timer (ot.enable_function_timing);
// Input image.
ot.read ();
ImageRecRef A (ot.pop());
const ImageBuf &Aib ((*A)());
// Get arguments from command line.
const char *size = argv[1];
int channel = atoi (argv[2]);
int cumulative = 0;
std::string cmd = argv[0];
size_t pos;
while ((pos = cmd.find_first_of(":")) != std::string::npos) {
cmd = cmd.substr (pos+1, std::string::npos);
if (Strutil::istarts_with(cmd,"cumulative="))
cumulative = atoi(cmd.c_str()+11);
}
// Extract bins and height from size.
int bins = 0, height = 0;
if (sscanf (size, "%dx%d", &bins, &height) != 2) {
ot.error (argv[0], Strutil::format ("Invalid size: %s", size));
return -1;
}
// Compute regular histogram.
std::vector<imagesize_t> hist;
bool ok = ImageBufAlgo::histogram (Aib, channel, hist, bins);
if (! ok) {
ot.error (argv[0], Aib.geterror());
return 0;
}
// Compute cumulative histogram if specified.
if (cumulative == 1)
for (int i = 1; i < bins; i++)
hist[i] += hist[i-1];
// Output image.
ImageSpec specR (bins, height, 1, TypeDesc::FLOAT);
ot.push (new ImageRec ("irec", specR, ot.imagecache));
ImageBuf &Rib ((*ot.curimg)());
ok = ImageBufAlgo::histogram_draw (Rib, hist);
if (! ok)
ot.error (argv[0], Rib.geterror());
ot.function_times["histogram"] += timer();
return 0;
}
// Concatenate the command line into one string, optionally filtering out
// verbose attribute commands.
static std::string
command_line_string (int argc, char * argv[], bool sansattrib)
{
std::string s;
for (int i = 0; i < argc; ++i) {
if (sansattrib) {
// skip any filtered attributes
if (!strcmp(argv[i], "--attrib") || !strcmp(argv[i], "-attrib") ||
!strcmp(argv[i], "--sattrib") || !strcmp(argv[i], "-sattrib")) {
i += 2; // also skip the following arguments
continue;
}
if (!strcmp(argv[i], "--sansattrib") || !strcmp(argv[i], "-sansattrib")) {
continue;
}
}
if (strchr (argv[i], ' ')) { // double quote args with spaces
s += '\"';
s += argv[i];
s += '\"';
} else {
s += argv[i];
}
if (i < argc-1)
s += ' ';
}
return s;
}
static void
getargs (int argc, char *argv[])
{
bool help = false;
bool sansattrib = false;
for (int i = 0; i < argc; ++i)
if (!strcmp(argv[i],"--sansattrib") || !strcmp(argv[i],"-sansattrib"))
sansattrib = true;
ot.full_command_line = command_line_string (argc, argv, sansattrib);
ArgParse ap (argc, (const char **)argv);
ap.options ("oiiotool -- simple image processing operations\n"
OIIO_INTRO_STRING "\n"
"Usage: oiiotool [filename,option,action]...\n",
"%*", input_file, "",
"<SEPARATOR>", "Options (general):",
"--help", &help, "Print help message",
"-v", &ot.verbose, "Verbose status messages",
"-q %!", &ot.verbose, "Quiet mode (turn verbose off)",
"--runstats", &ot.runstats, "Print runtime statistics",
"-a", &ot.allsubimages, "Do operations on all subimages/miplevels",
"--info", &ot.printinfo, "Print resolution and metadata on all inputs",
"--metamatch %s", &ot.printinfo_metamatch,
"Regex: which metadata is printed with -info -v",
"--no-metamatch %s", &ot.printinfo_nometamatch,
"Regex: which metadata is excluded with -info -v",
"--stats", &ot.printstats, "Print pixel statistics on all inputs",
"--dumpdata %@", set_dumpdata, NULL, "Print all pixel data values (options: empty=0)",
"--hash", &ot.hash, "Print SHA-1 hash of each input image",
"--colorcount %@ %s", action_colorcount, NULL,
"Count of how many pixels have the given color (argument: color;color;...) (options: eps=color)",
"--rangecheck %@ %s %s", action_rangecheck, NULL, NULL,
"Count of how many pixels are outside the low and high color arguments (each is a comma-separated color value list)",
// "-u", &ot.updatemode, "Update mode: skip outputs when the file exists and is newer than all inputs",
"--no-clobber", &ot.noclobber, "Do not overwrite existing files",
"--noclobber", &ot.noclobber, "", // synonym
"--threads %@ %d", set_threads, &ot.threads, "Number of threads (default 0 == #cores)",
"--frames %s", NULL, "Frame range for '#' or printf-style wildcards",
"--framepadding %d", NULL, "Frame number padding digits (ignored when using printf-style wildcards)",
"--views %s", NULL, "Views for %V/%v wildcards (comma-separated, defaults to left,right)",
"--wildcardoff", NULL, "Disable numeric wildcard expansion for subsequent command line arguments",
"--wildcardon", NULL, "Enable numeric wildcard expansion for subsequent command line arguments",
"--no-autopremult %@", unset_autopremult, NULL, "Turn off automatic premultiplication of images with unassociated alpha",
"--autopremult %@", set_autopremult, NULL, "Turn on automatic premultiplication of images with unassociated alpha",
"--autoorient", &ot.autoorient, "Automatically --reorient all images upon input",
"--auto-orient", &ot.autoorient, "", // symonym for --autoorient
"--native", &ot.nativeread, "Force native data type reads if cache would lose precision",
"<SEPARATOR>", "Commands that write images:",
"-o %@ %s", output_file, NULL, "Output the current image to the named file",
"<SEPARATOR>", "Options that affect subsequent image output:",
"-d %@ %s", set_dataformat, NULL,
"'-d TYPE' sets the output data format of all channels, "
"'-d CHAN=TYPE' overrides a single named channel (multiple -d args are allowed). "
"Data types include: uint8, sint8, uint10, uint12, uint16, sint16, uint32, sint32, half, float, double",
"--scanline", &ot.output_scanline, "Output scanline images",
"--tile %@ %d %d", output_tiles, &ot.output_tilewidth, &ot.output_tileheight,
"Output tiled images (tilewidth, tileheight)",
"--force-tiles", &ot.output_force_tiles, "", // undocumented
"--compression %s", &ot.output_compression, "Set the compression method",
"--quality %d", &ot.output_quality, "Set the compression quality, 1-100",
"--dither", &ot.output_dither, "Add dither to 8-bit output",
"--planarconfig %s", &ot.output_planarconfig,
"Force planarconfig (contig, separate, default)",
"--adjust-time", &ot.output_adjust_time,
"Adjust file times to match DateTime metadata",
"--noautocrop %!", &ot.output_autocrop,
"Do not automatically crop images whose formats don't support separate pixel data and full/display windows",
"--autotrim", &ot.output_autotrim,
"Automatically trim black borders upon output to file formats that support separate pixel data and full/display windows",
"<SEPARATOR>", "Options that change current image metadata (but not pixel values):",
"--attrib %@ %s %s", set_any_attribute, NULL, NULL, "Sets metadata attribute (name, value)",
"--sattrib %@ %s %s", set_string_attribute, NULL, NULL, "Sets string metadata attribute (name, value)",
"--caption %@ %s", set_caption, NULL, "Sets caption (ImageDescription metadata)",
"--keyword %@ %s", set_keyword, NULL, "Add a keyword",
"--clear-keywords %@", clear_keywords, NULL, "Clear all keywords",
"--nosoftwareattrib", &ot.metadata_nosoftwareattrib, "Do not write command line into Exif:ImageHistory, Software metadata attributes",
"--sansattrib", &sansattrib, "Write command line into Software & ImageHistory but remove --sattrib and --attrib options",
"--orientation %@ %d", set_orientation, NULL, "Set the assumed orientation",
"--orientcw %@", rotate_orientation, NULL, "Rotate orientation metadata 90 deg clockwise",
"--orientccw %@", rotate_orientation, NULL, "Rotate orientation metadata 90 deg counter-clockwise",
"--orient180 %@", rotate_orientation, NULL, "Rotate orientation metadata 180 deg",
"--rotcw %@", rotate_orientation, NULL, "", // DEPRECATED(1.5), back compatibility
"--rotccw %@", rotate_orientation, NULL, "", // DEPRECATED(1.5), back compatibility
"--rot180 %@", rotate_orientation, NULL, "", // DEPRECATED(1.5), back compatibility
"--origin %@ %s", set_origin, NULL,
"Set the pixel data window origin (e.g. +20+10)",
"--fullsize %@ %s", set_fullsize, NULL, "Set the display window (e.g., 1920x1080, 1024x768+100+0, -20-30)",
"--fullpixels %@", set_full_to_pixels, NULL, "Set the 'full' image range to be the pixel data window",
"--chnames %@ %s", set_channelnames, NULL,
"Set the channel names (comma-separated)",
"<SEPARATOR>", "Options that affect subsequent actions:",
"--fail %g", &ot.diff_failthresh, "Failure threshold difference (0.000001)",
"--failpercent %g", &ot.diff_failpercent, "Allow this percentage of failures in diff (0)",
"--hardfail %g", &ot.diff_hardfail, "Fail diff if any one pixel exceeds this error (infinity)",
"--warn %g", &ot.diff_warnthresh, "Warning threshold difference (0.00001)",
"--warnpercent %g", &ot.diff_warnpercent, "Allow this percentage of warnings in diff (0)",
"--hardwarn %g", &ot.diff_hardwarn, "Warn if any one pixel difference exceeds this error (infinity)",
"<SEPARATOR>", "Actions:",
"--create %@ %s %d", action_create, NULL, NULL,
"Create a blank image (args: geom, channels)",
"--pattern %@ %s %s %d", action_pattern, NULL, NULL, NULL,
"Create a patterned image (args: pattern, geom, channels)",
"--kernel %@ %s %s", action_kernel, NULL, NULL,
"Create a centered convolution kernel (args: name, geom)",
"--capture %@", action_capture, NULL,
"Capture an image (options: camera=%d)",
"--diff %@", action_diff, NULL, "Print report on the difference of two images (modified by --fail, --failpercent, --hardfail, --warn, --warnpercent --hardwarn)",
"--pdiff %@", action_pdiff, NULL, "Print report on the perceptual difference of two images (modified by --fail, --failpercent, --hardfail, --warn, --warnpercent --hardwarn)",
"--add %@", action_add, NULL, "Add two images",
"--sub %@", action_sub, NULL, "Subtract two images",
"--abs %@", action_abs, NULL, "Take the absolute value of the image pixels",
"--mul %@", action_mul, NULL, "Multiply two images",
"--cadd %s %@", action_cadd, NULL, "Add to all channels a scalar or per-channel constants (e.g.: 0.5 or 1,1.25,0.5)",
"--cmul %s %@", action_cmul, NULL, "Multiply the image values by a scalar or per-channel constants (e.g.: 0.5 or 1,1.25,0.5)",
"--cpow %s %@", action_cpow, NULL, "Raise the image values to a scalar or per-channel power (e.g.: 2.2 or 2.2,2.2,2.2,1.0)",
"--chsum %@", action_chsum, NULL,
"Turn into 1-channel image by summing channels (options: weight=r,g,...)",
"--crop %@ %s", action_crop, NULL, "Set pixel data resolution and offset, cropping or padding if necessary (WxH+X+Y or xmin,ymin,xmax,ymax)",
"--croptofull %@", action_croptofull, NULL, "Crop or pad to make pixel data region match the \"full\" region",
"--cut %@ %s", action_cut, NULL, "Cut out the ROI and reposition to the origin (WxH+X+Y or xmin,ymin,xmax,ymax)",
"--paste %@ %s", action_paste, NULL, "Paste fg over bg at the given position (e.g., +100+50)",
"--mosaic %@ %s", action_mosaic, NULL,
"Assemble images into a mosaic (arg: WxH; options: pad=0)",
"--over %@", action_over, NULL, "'Over' composite of two images",
"--zover %@", action_zover, NULL, "Depth composite two images with Z channels (options: zeroisinf=%d)",
"--histogram %@ %s %d", action_histogram, NULL, NULL, "Histogram one channel (options: cumulative=0)",
"--rotate90 %@", action_rotate90, NULL, "Rotate the image 90 degrees clockwise",
"--rotate180 %@", action_rotate180, NULL, "Rotate the image 180 degrees",
"--flipflop %@", action_rotate180, NULL, "", // Deprecated synonym for --rotate180
"--rotate270 %@", action_rotate270, NULL, "Rotate the image 270 degrees clockwise (or 90 degrees CCW)",
"--flip %@", action_flip, NULL, "Flip the image vertically (top<->bottom)",
"--flop %@", action_flop, NULL, "Flop the image horizontally (left<->right)",
"--reorient %@", action_reorient, NULL, "Rotate and/or flop the image to transform the pixels to match the Orientation metadata",
"--transpose %@", action_transpose, NULL, "Transpose the image",
"--cshift %@ %s", action_cshift, NULL, "Circular shift the image (e.g.: +20-10)",
"--resample %@ %s", action_resample, NULL, "Resample (640x480, 50%)",
"--resize %@ %s", action_resize, NULL, "Resize (640x480, 50%) (options: filter=%s)",
"--fit %@ %s", action_fit, NULL, "Resize to fit within a window size (options: filter=%s, pad=%d)",
"--rotate %@ %g", action_rotate, NULL, "Rotate pixels (argument is degrees clockwise) around the center of the display window (options: filter=%s, center=%f,%f, recompute_roi=%d",
"--warp %@ %s", action_warp, NULL, "Warp pixels (argument is a 3x3 matrix, separated by commas) (options: filter=%s, recompute_roi=%d)",
"--convolve %@", action_convolve, NULL,
"Convolve with a kernel",
"--blur %@ %s", action_blur, NULL,
"Blur the image (arg: WxH; options: kernel=name)",
"--median %@ %s", action_median, NULL,
"Median filter the image (arg: WxH)",
"--unsharp %@", action_unsharp, NULL,
"Unsharp mask (options: kernel=gaussian, width=3, contrast=1, threshold=0)",
"--fft %@", action_fft, NULL,
"Take the FFT of the image",
"--ifft %@", action_ifft, NULL,
"Take the inverse FFT of the image",
"--polar %@", action_polar, NULL,
"Convert complex (real,imag) to polar (amplitude,phase)",
"--unpolar %@", action_unpolar, NULL,
"Convert polar (amplitude,phase) to complex (real,imag)",
"--fixnan %@ %s", action_fixnan, NULL, "Fix NaN/Inf values in the image (options: none, black, box3)",
"--fillholes %@", action_fillholes, NULL,
"Fill in holes (where alpha is not 1)",
"--fill %@ %s", action_fill, NULL, "Fill a region (options: color=)",
"--clamp %@", action_clamp, NULL, "Clamp values (options: min=..., max=..., clampalpha=0)",
"--rangecompress %@", action_rangecompress, NULL,
"Compress the range of pixel values with a log scale (options: luma=0|1)",
"--rangeexpand %@", action_rangeexpand, NULL,
"Un-rangecompress pixel values back to a linear scale (options: luma=0|1)",
"--text %@ %s", action_text, NULL,
"Render text into the current image (options: x=, y=, size=, color=)",
"<SEPARATOR>", "Manipulating channels or subimages:",
"--ch %@ %s", action_channels, NULL,
"Select or shuffle channels (e.g., \"R,G,B\", \"B,G,R\", \"2,3,4\")",
"--chappend %@", action_chappend, NULL,
"Append the channels of the last two images",
"--unmip %@", action_unmip, NULL, "Discard all but the top level of a MIPmap",
"--selectmip %@ %d", action_selectmip, NULL,
"Select just one MIP level (0 = highest res)",
"--subimage %@ %d", action_select_subimage, NULL, "Select just one subimage",
"--siappend %@", action_subimage_append, NULL,
"Append the last two images into one multi-subimage image",
"--flatten %@", action_flatten, NULL, "Flatten deep image to non-deep",
"<SEPARATOR>", "Image stack manipulation:",
"--dup %@", action_dup, NULL,
"Duplicate the current image (push a copy onto the stack)",
"--swap %@", action_swap, NULL,
"Swap the top two images on the stack.",
"--pop %@", action_pop, NULL,
"Throw away the current image",
"--label %@ %s", action_label, NULL,
"Label the top image",
"<SEPARATOR>", "Color management:",
"--iscolorspace %@ %s", set_colorspace, NULL,
"Set the assumed color space (without altering pixels)",
"--tocolorspace %@ %s", action_tocolorspace, NULL,
"Convert the current image's pixels to a named color space",
"--colorconvert %@ %s %s", action_colorconvert, NULL, NULL,
"Convert pixels from 'src' to 'dst' color space (without regard to its previous interpretation)",
"--ociolook %@ %s", action_ociolook, NULL,
"Apply the named OCIO look (options: from=, to=, inverse=, key=, value=)",
"--ociodisplay %@ %s %s", action_ociodisplay, NULL, NULL,
"Apply the named OCIO display and view (options: from=, looks=, key=, value=)",
"--unpremult %@", action_unpremult, NULL,
"Divide all color channels of the current image by the alpha to \"un-premultiply\"",
"--premult %@", action_premult, NULL,
"Multiply all color channels of the current image by the alpha",
NULL);
if (ap.parse(argc, (const char**)argv) < 0) {
std::cerr << ap.geterror() << std::endl;
ap.usage ();
exit (EXIT_SUCCESS);
}
if (help || argc <= 1) {
ap.usage ();
// debugging color space names
std::stringstream s;
s << "Known color spaces: ";
const char *linear = ot.colorconfig.getColorSpaceNameByRole("linear");
for (int i = 0, e = ot.colorconfig.getNumColorSpaces(); i < e; ++i) {
const char *n = ot.colorconfig.getColorSpaceNameByIndex(i);
s << "\"" << n << "\"";
if (linear && !Strutil::iequals(n,"linear") &&
Strutil::iequals (n, linear))
s << " (linear)";
if (i < e-1)
s << ", ";
}
int columns = Sysutil::terminal_columns() - 2;
std::cout << Strutil::wordwrap(s.str(), columns, 4) << "\n";
int nlooks = ot.colorconfig.getNumLooks();
if (nlooks) {
std::stringstream s;
s << "Known looks: ";
for (int i = 0; i < nlooks; ++i) {
const char *n = ot.colorconfig.getLookNameByIndex(i);
s << "\"" << n << "\"";
if (i < nlooks-1)
s << ", ";
}
std::cout << Strutil::wordwrap(s.str(), columns, 4) << "\n";
}
const char *default_display = ot.colorconfig.getDefaultDisplayName();
int ndisplays = ot.colorconfig.getNumDisplays();
if (ndisplays) {
std::stringstream s;
s << "Known displays: ";
for (int i = 0; i < ndisplays; ++i) {
const char *d = ot.colorconfig.getDisplayNameByIndex(i);
s << "\"" << d << "\"";
if (! strcmp(d, default_display))
s << "*";
const char *default_view = ot.colorconfig.getDefaultViewName(d);
int nviews = ot.colorconfig.getNumViews(d);
if (nviews) {
s << " (views: ";
for (int i = 0; i < nviews; ++i) {
const char *v = ot.colorconfig.getViewNameByIndex(d, i);
s << "\"" << v << "\"";
if (! strcmp(v, default_view))
s << "*";
if (i < nviews-1)
s << ", ";
}
s << ")";
}
if (i < ndisplays-1)
s << ", ";
}
s << " (* = default)";
std::cout << Strutil::wordwrap(s.str(), columns, 4) << "\n";
}
if (! ot.colorconfig.supportsOpenColorIO())
std::cout << "No OpenColorIO support was enabled at build time.\n";
exit (EXIT_SUCCESS);
}
}
// Check if any of the command line arguments contains numeric ranges or
// wildcards. If not, just return 'false'. But if they do, the
// remainder of processing will happen here (and return 'true').
static bool
handle_sequence (int argc, const char **argv)
{
Timer totaltime;
// First, scan the original command line arguments for '#', '@', '%0Nd',
// '%v' or '%V' characters. Any found indicate that there are numeric
// range or wildcards to deal with. Also look for --frames,
// --framepadding and --views options.
#define ONERANGE_SPEC "[0-9]+(-[0-9]+((x|y)-?[0-9]+)?)?"
#define MANYRANGE_SPEC ONERANGE_SPEC "(," ONERANGE_SPEC ")*"
#define VIEW_SPEC "%[Vv]"
#define SEQUENCE_SPEC "((" MANYRANGE_SPEC ")?" "((#|@)+|(%[0-9]*d)))" "|" "(" VIEW_SPEC ")"
static boost::regex sequence_re (SEQUENCE_SPEC);
std::string framespec = "";
static const char *default_views = "left,right";
std::vector<string_view> views;
Strutil::split (default_views, views, ",");
int framepadding = 0;
std::vector<int> sequence_args; // Args with sequence numbers
std::vector<bool> sequence_is_output;
bool is_sequence = false;
bool wildcard_on = true;
for (int a = 1; a < argc; ++a) {
bool is_output = false;
if (! strcmp (argv[a], "-o") && a < argc-1) {
is_output = true;
a++;
}
std::string strarg (argv[a]);
boost::match_results<std::string::const_iterator> range_match;
if ((strarg == "--frames" || strarg == "-frames") && a < argc-1) {
framespec = argv[++a];
}
else if ((strarg == "--framepadding" || strarg == "-framepadding")
&& a < argc-1) {
int f = atoi (argv[++a]);
if (f >= 1 && f < 10)
framepadding = f;
}
else if ((strarg == "--views" || strarg == "-views") && a < argc-1) {
Strutil::split (argv[++a], views, ",");
}
else if (strarg == "--wildcardoff" || strarg == "-wildcardoff") {
wildcard_on = false;
}
else if (strarg == "--wildcardon" || strarg == "-wildcardon") {
wildcard_on = true;
}
else if (wildcard_on &&
boost::regex_search (strarg, range_match, sequence_re)) {
is_sequence = true;
sequence_args.push_back (a);
sequence_is_output.push_back (is_output);
}
}
// No ranges or wildcards?
if (! is_sequence)
return false;
// For each of the arguments that contains a wildcard, get a normalized
// pattern in printf style (e.g. "foo.%04d.exr"). Next, either expand the
// frame pattern to a list of frame numbers and use enumerate_file_sequence
// to fully elaborate all the filenames in the sequence, or if no frame
// range was specified, scan the filesystem for matching frames. Output
// sequences without explicit frame ranges inherit the frame numbers of
// the first input sequence. It's an error if the sequences are not all
// of the same length.
std::vector< std::vector<std::string> > filenames (argc+1);
std::vector< std::vector<int> > frame_numbers (argc+1);
std::vector< std::vector<string_view> > frame_views (argc+1);
std::string normalized_pattern, sequence_framespec;
size_t nfilenames = 0;
bool result;
for (size_t i = 0; i < sequence_args.size(); ++i) {
int a = sequence_args[i];
result = Filesystem::parse_pattern (argv[a],
framepadding,
normalized_pattern,
sequence_framespec);
if (! result) {
ot.error (Strutil::format("Could not parse pattern: %s",
argv[a]), "");
return true;
}
// --frames overrides sequence framespec
if (! framespec.empty())
sequence_framespec = framespec;
if (! sequence_framespec.empty()) {
Filesystem::enumerate_sequence (sequence_framespec.c_str(),
frame_numbers[a]);
Filesystem::enumerate_file_sequence (normalized_pattern,
frame_numbers[a],
views,
filenames[a]);
} else if (sequence_is_output[i]) {
// use frame numbers from first sequence
Filesystem::enumerate_file_sequence (normalized_pattern,
frame_numbers[sequence_args[0]],
frame_views[sequence_args[0]],
filenames[a]);
} else if (! sequence_is_output[i]) {
result = Filesystem::scan_for_matching_filenames (normalized_pattern,
views,
frame_numbers[a],
frame_views[a],
filenames[a]);
if (! result) {
ot.error (Strutil::format("No filenames found matching pattern: \"%s\" (did you intend to use --wildcardoff?)",
argv[a]), "");
return true;
}
}
if (i == 0) {
nfilenames = filenames[a].size();
} else if (nfilenames != filenames[a].size()) {
ot.error (Strutil::format("Not all sequence specifications matched: %s (%d frames) vs. %s (%d frames)",
argv[sequence_args[0]], nfilenames, argv[a], filenames[a].size()), "");
return true;
}
}
// OK, now we just call getargs once for each item in the sequences,
// substituting the i-th sequence entry for its respective argument
// every time.
std::vector<const char *> seq_argv (argv, argv+argc+1);
for (size_t i = 0; i < nfilenames; ++i) {
for (size_t j = 0; j < sequence_args.size(); ++j) {
size_t a = sequence_args[j];
seq_argv[a] = filenames[a][i].c_str();
}
ot.clear_options (); // Careful to reset all command line options!
getargs (argc, (char **)&seq_argv[0]);
ot.process_pending ();
if (ot.pending_callback())
ot.warning (Strutil::format ("pending '%s' command never executed", ot.pending_callback_name()));
// Clear the stack at the end of each iteration
ot.curimg.reset ();
ot.image_stack.clear();
if (ot.runstats)
std::cout << "End iteration " << i << ": "
<< Strutil::timeintervalformat(totaltime(),2) << " "
<< Strutil::memformat(Sysutil::memory_used()) << "\n";
}
return true;
}
int
main (int argc, char *argv[])
{
// When Visual Studio is used float values in scientific format are printed
// with three digit exponent. We change this behavior to fit the Linux way.
#ifdef _MSC_VER
_set_output_format (_TWO_DIGIT_EXPONENT);
#endif
Timer totaltime;
ot.imagecache = ImageCache::create (false);
ASSERT (ot.imagecache);
ot.imagecache->attribute ("forcefloat", 1);
ot.imagecache->attribute ("m_max_memory_MB", 4096.0);
// ot.imagecache->attribute ("autotile", 1024);
Filesystem::convert_native_arguments (argc, (const char **)argv);
if (handle_sequence (argc, (const char **)argv)) {
// Deal with sequence
} else {
// Not a sequence
getargs (argc, argv);
ot.process_pending ();
if (ot.pending_callback())
ot.warning (Strutil::format ("pending '%s' command never executed", ot.pending_callback_name()));
}
if (ot.runstats) {
double total_time = totaltime();
double unaccounted = total_time;
std::cout << "\n";
int threads = -1;
OIIO::getattribute ("threads", threads);
std::cout << "Threads: " << threads << "\n";
std::cout << "oiiotool runtime statistics:\n";
std::cout << " Total time: " << Strutil::timeintervalformat(total_time,2) << "\n";
static const char *timeformat = " %-12s : %5.2f\n";
for (Oiiotool::TimingMap::const_iterator func = ot.function_times.begin();
func != ot.function_times.end(); ++func) {
double t = func->second;
std::cout << Strutil::format (timeformat, func->first, t);
unaccounted -= t;
}
std::cout << Strutil::format (timeformat, "unaccounted", std::max(unaccounted, 0.0));
std::cout << ot.imagecache->getstats() << "\n";
}
return ot.return_value;
}
|
// -*- mode: c++; c-basic-offset:4 -*-
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
// Copyright (c) 2013 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin D4Opaqueeet, Fifth Floor, Boston, MA 02110-1301 USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
#define DODS_DEBUG
#include "config.h"
#include <sstream>
#include <iterator>
#include "D4Opaque.h"
#include "DMR.h"
#include "D4StreamMarshaller.h"
#include "D4StreamUnMarshaller.h"
#include "util.h"
#include "crc.h"
#include "debug.h"
#undef CLEAR_LOCAL_DATA
using namespace std;
namespace libdap {
D4Opaque &
D4Opaque::operator=(const D4Opaque &rhs)
{
if (this == &rhs)
return *this;
// Call BaseType::operator=
dynamic_cast<BaseType &>(*this) = rhs;
d_buf = rhs.d_buf;
return *this;
}
void
D4Opaque::clear_local_data()
{
if (!d_buf.empty()) {
d_buf.erase(d_buf.begin(), d_buf.end());
d_buf.resize(0);
}
set_read_p(false);
}
void
D4Opaque::compute_checksum(Crc32 &checksum)
{
checksum.AddData(&d_buf[0], d_buf.size());
}
void
D4Opaque::serialize(D4StreamMarshaller &m, DMR &, bool)
{
if (!read_p())
read(); // read() throws Error
m.put_opaque_dap4( reinterpret_cast<char*>(&d_buf[0]), d_buf.size() ) ;
#ifdef CLEAR_LOCAL_DATA
clear_local_data();
#endif
}
void
D4Opaque::deserialize(D4StreamUnMarshaller &um, DMR &)
{
um.get_opaque_dap4( d_buf ) ;
}
unsigned int
D4Opaque::buf2val(void **val)
{
assert(val);
// If *val is null, then the caller has not allocated storage for the
// value; we must. If there is storage there, assume it is a vector<uint8_t>
// (i.e., dods_opaque) and assign d_buf's value to that storage.
if (!*val)
*val = new vector<uint8_t>;
else
*static_cast<vector<uint8_t>*>(*val) = d_buf;
return sizeof(vector<uint8_t>*);
}
unsigned int
D4Opaque::val2buf(void *val, bool)
{
assert(val);
d_buf = *static_cast<dods_opaque*>(val);
return sizeof(dods_opaque*);
}
/** Set the value of this instance.
@param value The value
@return Always returns true; the return type of bool is for compatibility
with the Passive* subclasses written by HAO. */
bool
D4Opaque::set_value(const dods_opaque &value)
{
d_buf = value;
set_read_p(true);
return true;
}
/** Get the value of this instance.
@return The value. */
D4Opaque::dods_opaque
D4Opaque::value() const
{
return d_buf;
}
std::vector<BaseType *> *
D4Opaque::transform_to_dap2(AttrTable *){
DBG(cerr << __func__ << "() - Transform not implemented DAP4 Opaque type." << endl;);
return NULL;
}
void
D4Opaque::print_val(ostream &out, string space, bool print_decl_p)
{
if (print_decl_p) print_decl(out, space, false);
if (d_buf.size()) {
// end() - 1 is only OK if size() is > 0
std::ostream_iterator<unsigned int> out_it(out, ",");
std::copy(d_buf.begin(), d_buf.end() - 1, out_it);
out << (unsigned int) d_buf.back(); // can also use: *(d_buf.end()-1);
}
if (print_decl_p) out << ";" << endl;
}
void
D4Opaque::dump(ostream &strm) const
{
strm << DapIndent::LMarg << "D4Opaque::dump - ("
<< (void *)this << ")" << endl ;
DapIndent::Indent() ;
BaseType::dump(strm) ;
//strm << DapIndent::LMarg << "value: " << d_buf << endl ;
ostream_iterator<uint8_t> out_it (strm," ");
std::copy ( d_buf.begin(), d_buf.end(), out_it );
DapIndent::UnIndent() ;
}
} // namespace libdap
Silencing more debug chatter.
// -*- mode: c++; c-basic-offset:4 -*-
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
// Copyright (c) 2013 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin D4Opaqueeet, Fifth Floor, Boston, MA 02110-1301 USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
//#define DODS_DEBUG
#include "config.h"
#include <sstream>
#include <iterator>
#include "D4Opaque.h"
#include "DMR.h"
#include "D4StreamMarshaller.h"
#include "D4StreamUnMarshaller.h"
#include "util.h"
#include "crc.h"
#include "debug.h"
#undef CLEAR_LOCAL_DATA
using namespace std;
namespace libdap {
D4Opaque &
D4Opaque::operator=(const D4Opaque &rhs)
{
if (this == &rhs)
return *this;
// Call BaseType::operator=
dynamic_cast<BaseType &>(*this) = rhs;
d_buf = rhs.d_buf;
return *this;
}
void
D4Opaque::clear_local_data()
{
if (!d_buf.empty()) {
d_buf.erase(d_buf.begin(), d_buf.end());
d_buf.resize(0);
}
set_read_p(false);
}
void
D4Opaque::compute_checksum(Crc32 &checksum)
{
checksum.AddData(&d_buf[0], d_buf.size());
}
void
D4Opaque::serialize(D4StreamMarshaller &m, DMR &, bool)
{
if (!read_p())
read(); // read() throws Error
m.put_opaque_dap4( reinterpret_cast<char*>(&d_buf[0]), d_buf.size() ) ;
#ifdef CLEAR_LOCAL_DATA
clear_local_data();
#endif
}
void
D4Opaque::deserialize(D4StreamUnMarshaller &um, DMR &)
{
um.get_opaque_dap4( d_buf ) ;
}
unsigned int
D4Opaque::buf2val(void **val)
{
assert(val);
// If *val is null, then the caller has not allocated storage for the
// value; we must. If there is storage there, assume it is a vector<uint8_t>
// (i.e., dods_opaque) and assign d_buf's value to that storage.
if (!*val)
*val = new vector<uint8_t>;
else
*static_cast<vector<uint8_t>*>(*val) = d_buf;
return sizeof(vector<uint8_t>*);
}
unsigned int
D4Opaque::val2buf(void *val, bool)
{
assert(val);
d_buf = *static_cast<dods_opaque*>(val);
return sizeof(dods_opaque*);
}
/** Set the value of this instance.
@param value The value
@return Always returns true; the return type of bool is for compatibility
with the Passive* subclasses written by HAO. */
bool
D4Opaque::set_value(const dods_opaque &value)
{
d_buf = value;
set_read_p(true);
return true;
}
/** Get the value of this instance.
@return The value. */
D4Opaque::dods_opaque
D4Opaque::value() const
{
return d_buf;
}
std::vector<BaseType *> *
D4Opaque::transform_to_dap2(AttrTable *){
DBG(cerr << __func__ << "() - Transform not implemented DAP4 Opaque type." << endl;);
return NULL;
}
void
D4Opaque::print_val(ostream &out, string space, bool print_decl_p)
{
if (print_decl_p) print_decl(out, space, false);
if (d_buf.size()) {
// end() - 1 is only OK if size() is > 0
std::ostream_iterator<unsigned int> out_it(out, ",");
std::copy(d_buf.begin(), d_buf.end() - 1, out_it);
out << (unsigned int) d_buf.back(); // can also use: *(d_buf.end()-1);
}
if (print_decl_p) out << ";" << endl;
}
void
D4Opaque::dump(ostream &strm) const
{
strm << DapIndent::LMarg << "D4Opaque::dump - ("
<< (void *)this << ")" << endl ;
DapIndent::Indent() ;
BaseType::dump(strm) ;
//strm << DapIndent::LMarg << "value: " << d_buf << endl ;
ostream_iterator<uint8_t> out_it (strm," ");
std::copy ( d_buf.begin(), d_buf.end(), out_it );
DapIndent::UnIndent() ;
}
} // namespace libdap
|
/* crosstest.py --test=test_global.cpp \
--driver=test_global_main.cpp --prefix=Subzero_ --output=test_global */
#include <stdint.h>
#include <cstdlib>
#include <iostream>
#include "test_global.h"
namespace Subzero_ {
#include "test_global.h"
}
int main(int argc, char **argv) {
size_t TotalTests = 0;
size_t Passes = 0;
size_t Failures = 0;
const uint8_t *SzArray, *LlcArray;
size_t SzArrayLen, LlcArrayLen;
size_t NumArrays = getNumArrays();
for (size_t i = 0; i < NumArrays; ++i) {
LlcArrayLen = -1;
SzArrayLen = -2;
LlcArray = getArray(i, LlcArrayLen);
SzArray = Subzero_::getArray(i, SzArrayLen);
if (LlcArrayLen == SzArrayLen) {
++Passes;
} else {
std::cout << i << ":LlcArrayLen=" << LlcArrayLen
<< ", SzArrayLen=" << SzArrayLen << std::endl;
++Failures;
}
for (size_t i = 0; i < LlcArrayLen; ++i) {
if (LlcArray[i] == SzArray[i]) {
++Passes;
} else {
++Failures;
std::cout << i << ":LlcArray[" << i << "] = " << (int)LlcArray[i]
<< ", SzArray[" << i << "] = " << (int)SzArray[i]
<< std::endl;
}
}
}
std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
<< " Failures=" << Failures << "\n";
return Failures;
}
Fix a counter in the test_global crosstest.
Change TotalTests so that the test count matches up with the number of
recorded passes and failures.
BUG=none
R=stichnot@chromium.org
Review URL: https://codereview.chromium.org/415803004
/* crosstest.py --test=test_global.cpp \
--driver=test_global_main.cpp --prefix=Subzero_ --output=test_global */
#include <stdint.h>
#include <cstdlib>
#include <iostream>
#include "test_global.h"
namespace Subzero_ {
#include "test_global.h"
}
int main(int argc, char **argv) {
size_t TotalTests = 0;
size_t Passes = 0;
size_t Failures = 0;
const uint8_t *SzArray, *LlcArray;
size_t SzArrayLen, LlcArrayLen;
size_t NumArrays = getNumArrays();
for (size_t i = 0; i < NumArrays; ++i) {
LlcArrayLen = -1;
SzArrayLen = -2;
LlcArray = getArray(i, LlcArrayLen);
SzArray = Subzero_::getArray(i, SzArrayLen);
++TotalTests;
if (LlcArrayLen == SzArrayLen) {
++Passes;
} else {
std::cout << i << ":LlcArrayLen=" << LlcArrayLen
<< ", SzArrayLen=" << SzArrayLen << std::endl;
++Failures;
}
for (size_t i = 0; i < LlcArrayLen; ++i) {
++TotalTests;
if (LlcArray[i] == SzArray[i]) {
++Passes;
} else {
++Failures;
std::cout << i << ":LlcArray[" << i << "] = " << (int)LlcArray[i]
<< ", SzArray[" << i << "] = " << (int)SzArray[i]
<< std::endl;
}
}
}
std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
<< " Failures=" << Failures << "\n";
return Failures;
}
|
/// PrecompData_test.cpp
/** Test the PrecompData class
*/
#include "PrecompData.h"
#include "PrecompData_test.h"
#include <cassert>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using Utilities::PrecompData;
typedef PrecompData<100, float, float, 2> pcd12; // f: x --> (y, z)
float TestFunc(float x) {
return sin(x);
}
float TestFuncLin(float x) { // y = 2x
return 2*x;
}
float TestFuncNonLin1(float x) { // y = |x|
return fabs(x);
}
float TestFuncNonLin2(float x) { // y = 1/(|x-2| + 0.1)
return 1/(fabs(x - 2.0f) + 0.1f);
}
float TestFuncNonLinSin(float x) { // y = sin(x)
return sin(x);
}
pcd12::YData TestFunc12(float x) { // y1 = sin(x); y2 = cos(x)
pcd12::YData y;
y[0] = sin(x);
y[1] = cos(x);
return y;
}
namespace Utilities {
template <typename T = float>
bool TestEqAbs(T value, T expected, T tolerance = 0.01f)
{
if(fabs(value - expected) <= tolerance)
return true; // success
return false; // failure
}
template <typename T = float>
bool TestEqRel(T value, T expected, T tolerance = 0.01f)
{
if(fabs((value - expected)/expected) <= tolerance)
return true; // success
return false; // failure
}
PrecompData_test::PrecompData_test()
{
using namespace Utilities;
cout << fixed;
const int nValues = 20;
const float tol = 0.01f; // tolerance
// Test - Conversions ScalarToIndex
{
cout << "\n\nTest: Conversion scalar --> index: " << flush;
const string funcName = "TestFunc";
PrecompData<nValues> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.Set(&TestFunc, x0, x1);
assert(TestEqAbs(itp.ScalarToIndex(x0), size_t(0), size_t(0)) && "Test: Conversion scalar --> index FAILED on first element.");
assert(TestEqAbs(itp.ScalarToIndex((x1 - x0)/2.0f), size_t(nValues/2), size_t(0)) && "Test: Conversion scalar --> index FAILED on the middle element.");
assert(TestEqAbs(itp.ScalarToIndex(x1), size_t(nValues), size_t(0)) && "Test: Conversion scalar --> index FAILED on last element.");
cout << " OK" << endl;
}
// Test - Conversions IndexToScalar
{
cout << "\n\nTest: Conversion index --> scalar: " << flush;
const string funcName = "TestFunc";
PrecompData<nValues> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.Set(&TestFunc, x0, x1);
assert(TestEqAbs(itp.IndexToScalar(0), x0, tol) && "Test: Conversion index --> scalar FAILED on first element.");
assert(TestEqAbs(itp.IndexToScalar(nValues/2), (x1 - x0)/2.0f, tol) && "Test: Conversion index --> scalar FAILED on the middle element.");
assert(TestEqAbs(itp.IndexToScalar(nValues), x1, tol) && "Test: Conversion index --> scalar FAILED on last element.");
cout << " OK" << endl;
}
// Test - Test mathematical functions
{
cout << "\n\nTest: Test mathematical functions: " << endl;
float x = 0.0f;
pcd12::YData y, y_ok;
y_ok[0] = 1.0;
y = TestFunc12(x);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
x = 3.141f;
y_ok[0] = -1.0;
y = TestFunc12(x);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
x = 6.282f;
y_ok[0] = 1.0;
y = TestFunc12(x);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
cout << " OK" << endl;
}
// Test - Conversions VectorToIndex //+TODO
{
cout << "\n\nTest: Conversion vector --> index: " << flush;
const string funcName = "TestFunc";
pcd12 itp(funcName);
itp.SetComment("Y = f(X) X = x(i,j), Y = y(i)");
const float x0 = 0.00f;
const float x1 = 6.28f;
itp.Set(&TestFunc12, x0, x1, nValues*nValues);
//itp.Dump();
itp.Dump(10);
itp.Dump(-10);
pcd12::YData y, y_ok;
y = itp(x0);
y_ok = TestFunc12(x0);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
y = itp(x1);
y_ok = TestFunc12(x1);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
{//+TEMP
cerr << endl;
cerr << itp.VectorToIndex(x0) << " = " << size_t(0) << endl;
cerr << itp.VectorToIndex(x1) << " = " << size_t(nValues*nValues) << endl;
cerr << itp.VectorToIndex((x1 - x0)/2.0f) << " = " << size_t(nValues*nValues/2) << endl;
}
assert(TestEqAbs(itp.VectorToIndex(x0), size_t(0), size_t(0)) && "Test: Conversion vector --> index FAILED on first element.");
assert(TestEqAbs(itp.VectorToIndex(x1), size_t(nValues*nValues), size_t(0)) && "Test: Conversion vector --> index FAILED on last element.");
assert(TestEqAbs(itp.VectorToIndex((x1 - x0)/2.0f), size_t(nValues*nValues/2), size_t(0)) && "Test: Conversion vector --> index FAILED on the middle element.");
cout << " OK" << endl;
}
// Test - Zero-degree interpolation (R --> R)
{
cout << "\n\nTest: Zero-degree (nearest-neighbor/point sampling/Voronoi) interpolation:" << endl;
const string funcName = "TestFunc";
PrecompData<nValues> itp(funcName); // default: float type
itp.SetComment("TestFunc approximation");
const float x0 = 0.0f, x1 = 6.28f;
const float step = 0.5f*(x1 - x0)/nValues;
itp.Set(&TestFunc, x0, x1);
float x = x0;
float err = 0.0f;
itp.Interpolation(0);
cout << "Interpolation: " << itp.Interpolation() << endl;
for(int i = 0; i < nValues; ++i) {
const float y = itp(x);
err += fabs(TestFunc(x) - y);
cout << i << ":\t" << funcName << "(" << x << ") = " << TestFunc(x) << " ~ " << y << endl;
x += step;
}
cout << "Total error = " << err << endl;
}
// Test - Linear interpolation (R --> R)
{
cout << "\n\nTest: Linear interpolation:" << endl;
const string funcName = "TestFunc";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
const float step = 0.5f*(x1 - x0)/nValues;
itp.Set(&TestFunc, x0, x1);
float x = x0;
float err = 0.0f;
itp.Interpolation(1);
cout << "Interpolation: " << itp.Interpolation() << endl;
for(int i = 0; i < nValues; ++i) {
const float y = itp.Interpolate(x);
err += fabs(TestFunc(x) - y);
cout << i << ":\t" << funcName << "(" << x << ") = " << TestFunc(x) << " ~ " << y << endl;
x += step;
}
cout << "Total error = " << err << endl;
}
// Test - AutoSet (R --> R): y = 2x
{
cout << "\n\nTest: Automatic irregular grid: y = 2x" << endl;
const string funcName = "y = 2x";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.AutoSet(&TestFuncLin, x0, x1);
cerr << "x0 = " << x0 << " x1 = " << x1 << " nValues = " << nValues << endl; //+T+
std::vector<float> vx, vy;
itp.Get(vx, vy);
cout << "Sizes: x = " << vx.size() << "; y = " << vy.size() << endl;
for(size_t i = 0; i < nValues; ++i) {
cout << i << ": " << vx[i] << ", " << vy[i] << endl;
}
}
// Test - AutoSet (R --> R): y = 1/(|x-2| + 0.1)
{
cout << "\n\nTest: Automatic irregular grid: y = 1/(|x-2| + 0.1)" << endl;
const string funcName = "y = 1/(|x-2| + 0.1)";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.AutoSet(&TestFuncNonLin2, x0, x1);
cerr << "x0 = " << x0 << " x1 = " << x1 << " nValues = " << nValues << endl; //+T+
std::vector<float> vx, vy;
itp.Get(vx, vy);
cout << "Sizes: x = " << vx.size() << "; y = " << vy.size() << endl;
for(size_t i = 0; i < nValues; ++i) {
cout << i << ": " << vx[i] << ", " << vy[i] << endl;
}
}
// Test - Derivatives
{
cout << "\n\nTest: Derivatives" << endl;
int nTests = 0, nFailed = 0;
const string funcName = "Derivatives";
float x1, y1, x2, y2, x3, y3, der1, der2, expRes;
PrecompData<nValues, float> test;
// First derivative
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 0.0; expRes = 0.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 1" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 1.0; expRes = 1.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 2" << endl;
}
x1 = 1.0; y1 = 0.0; x2 = 0.0; y2 = 1.0; expRes = -1.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 3" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 2.0; y2 = 1.0; expRes = 0.5;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 4" << endl;
}
x1 = 0.0; y1 = -1.0; x2 = 1.0; y2 = 1.0; expRes = 2.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 5" << endl;
}
x1 = 0.0; y1 = 1.0; x2 = 1.0; y2 = 1.0; expRes = 0.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 6" << endl;
}
// Second derivative
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 0.0; x3 = 2.0; y3 = 0.0; expRes = 0.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 1" << endl;
}
x1 = 0.0; y1 = 1.0; x2 = 1.0; y2 = 1.0; x3 = 2.0; y3 = 1.0; expRes = 0.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 2" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 1.0; x3 = 2.0; y3 = 2.0; expRes = 0.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 3" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 1.0; x3 = 2.0; y3 = 4.0; expRes = 2.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 4: Result = " << der2 << "; Expected = " << expRes << endl;
}
cout << "Derivatives: Number of tests = " << nTests << "; Number of failures = " << nFailed << endl;
}
// Test - AutoSet: y = sin(x)
// Result: values too concentrated in the points with high absolute second derivative
{
cout << "\n\nTest: Automatic irregular grid: y = sin(x)" << endl;
const string funcName = "y = sin(x)";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.SetOversampling(1.5f);
itp.AutoSet(&TestFuncNonLinSin, x0, x1);
cerr << "x0 = " << x0 << " x1 = " << x1 << " nValues = " << nValues << endl; //+T+
std::vector<float> vx, vy;
itp.Get(vx, vy);
cout << "Sizes: x = " << vx.size() << "; y = " << vy.size() << endl;
for(size_t i = 0; i < nValues; ++i) {
cout << i << ": " << vx[i] << ", " << vy[i] << endl;
}
int n = 100;
cout << "Compare approximation with real sin(x) function (done on " << n << " points):" << endl;
float error = 0.0f, avgErr = 0.0f;
float minErrX = 1.0e20f, minErrY = 1.0e20f;
float maxErrX = 0.0f, maxErrY = 0.0f;
float x = x0, step = (x1 - x0)/n;
for(int i = 0; i < n; ++i) {
error = fabs(sin(x) - itp.Interpolate(x));
cout << i << ": \t" << x << ", \t " << sin(x) << ", \t " << itp.Interpolate(x) << ", \t " << error << endl;
if(error < minErrY) { minErrX = x; minErrY = error; }
if(error > maxErrY) { maxErrX = x; maxErrY = error; }
avgErr += error;
x += step;
}
avgErr /= n;
cout << "Result: minimum error = [" << minErrX << ", " << minErrY
<< "]; maximum error = [" << maxErrX << ", " << maxErrY
<< "]; average error = " << avgErr << endl;
}
// Test - Multidimensions: Storage of data in an NxM space
{
cout << "\n\nTest: Storage of data in an NxM space:" << endl;
const string funcName = "Multidimensions";
pcd12 itp(funcName);
itp.SetComment("Y = f(X) X = x(i,j), Y = y(i)");
pcd12::X x0 = { { 0.00f, 0.00f } }; // coordinates of the starting point
pcd12::X x1 = { { 6.28f, 6.28f } }; // coordinates of the end point
const pcd12::X step = { { 0.5f*(x1[0] - x0[0])/nValues,
0.5f*(x1[1] - x0[1])/nValues } };
itp.Set(&TestFunc12, x0, x1, nValues*nValues);
pcd12::X x = x0;
float err = 0.0f;
for(int j = 0; j < nValues; ++j)
{
x[0] = x0[0];
for(int i = 0; i < nValues; ++i)
{
const pcd12::Y y = itp(x); //+B
err += fabs(TestFunc12(x)[0] - y[0]);
cout << i << ":\t" << funcName << "[" << x[0] << ", " << x[1] << "] = " << TestFunc12(x)[0] << " ~ " << y[0] << endl;
x[0] += step[0];
}
x[1] += step[1];
}
cout << "Total error = " << err << endl;
}
}
} // Utilities
int main()
{
using namespace Utilities;
PrecompData_test test;
return 0;
}
- Disabled a test, no longer relevant.
/// PrecompData_test.cpp
/** Test the PrecompData class
*/
#include "PrecompData.h"
#include "PrecompData_test.h"
#include <cassert>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using Utilities::PrecompData;
typedef PrecompData<100, float, float, 2> pcd12; // f: x --> (y, z)
float TestFunc(float x) {
return sin(x);
}
float TestFuncLin(float x) { // y = 2x
return 2*x;
}
float TestFuncNonLin1(float x) { // y = |x|
return fabs(x);
}
float TestFuncNonLin2(float x) { // y = 1/(|x-2| + 0.1)
return 1/(fabs(x - 2.0f) + 0.1f);
}
float TestFuncNonLinSin(float x) { // y = sin(x)
return sin(x);
}
pcd12::YData TestFunc12(float x) { // y1 = sin(x); y2 = cos(x)
pcd12::YData y;
y[0] = sin(x);
y[1] = cos(x);
return y;
}
namespace Utilities {
template <typename T = float>
bool TestEqAbs(T value, T expected, T tolerance = 0.01f)
{
if(fabs(value - expected) <= tolerance)
return true; // success
return false; // failure
}
template <typename T = float>
bool TestEqRel(T value, T expected, T tolerance = 0.01f)
{
if(fabs((value - expected)/expected) <= tolerance)
return true; // success
return false; // failure
}
PrecompData_test::PrecompData_test()
{
using namespace Utilities;
cout << fixed;
const int nValues = 20;
const float tol = 0.01f; // tolerance
// Test - Conversions ScalarToIndex
{
cout << "\n\nTest: Conversion scalar --> index: " << flush;
const string funcName = "TestFunc";
PrecompData<nValues> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.Set(&TestFunc, x0, x1);
assert(TestEqAbs(itp.ScalarToIndex(x0), size_t(0), size_t(0)) && "Test: Conversion scalar --> index FAILED on first element.");
assert(TestEqAbs(itp.ScalarToIndex((x1 - x0)/2.0f), size_t(nValues/2), size_t(0)) && "Test: Conversion scalar --> index FAILED on the middle element.");
assert(TestEqAbs(itp.ScalarToIndex(x1), size_t(nValues), size_t(0)) && "Test: Conversion scalar --> index FAILED on last element.");
cout << " OK" << endl;
}
// Test - Conversions IndexToScalar
{
cout << "\n\nTest: Conversion index --> scalar: " << flush;
const string funcName = "TestFunc";
PrecompData<nValues> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.Set(&TestFunc, x0, x1);
assert(TestEqAbs(itp.IndexToScalar(0), x0, tol) && "Test: Conversion index --> scalar FAILED on first element.");
assert(TestEqAbs(itp.IndexToScalar(nValues/2), (x1 - x0)/2.0f, tol) && "Test: Conversion index --> scalar FAILED on the middle element.");
assert(TestEqAbs(itp.IndexToScalar(nValues), x1, tol) && "Test: Conversion index --> scalar FAILED on last element.");
cout << " OK" << endl;
}
// Test - Test mathematical functions
{
cout << "\n\nTest: Test mathematical functions: " << endl;
float x = 0.0f;
pcd12::YData y, y_ok;
y_ok[0] = 1.0;
y = TestFunc12(x);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
x = 3.141f;
y_ok[0] = -1.0;
y = TestFunc12(x);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
x = 6.282f;
y_ok[0] = 1.0;
y = TestFunc12(x);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
cout << " OK" << endl;
}
//+D? Test - Conversions VectorToIndex //+TODO
/*{
cout << "\n\nTest: Conversion vector --> index: " << flush;
const string funcName = "TestFunc";
pcd12 itp(funcName);
itp.SetComment("Y = f(X) X = x(i,j), Y = y(i)");
const float x0 = 0.00f;
const float x1 = 6.28f;
itp.Set(&TestFunc12, x0, x1);
//itp.Dump();
itp.Dump(10);
itp.Dump(-10);
pcd12::YData y, y_ok;
y = itp(x0);
y_ok = TestFunc12(x0);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
y = itp(x1);
y_ok = TestFunc12(x1);
cerr << "Expected result = " << y_ok[0] << "; Actual result = " << y[0] << endl;
assert(abs(y[0] - y_ok[0]) < 1.0e-2f);
{//+TEMP
cerr << endl;
cerr << itp.VectorToIndex(x0) << " = " << size_t(0) << endl;
cerr << itp.VectorToIndex(x1) << " = " << size_t(nValues*nValues) << endl;
cerr << itp.VectorToIndex((x1 - x0)/2.0f) << " = " << size_t(nValues*nValues/2) << endl;
}
assert(TestEqAbs(itp.VectorToIndex(x0), size_t(0), size_t(0)) && "Test: Conversion vector --> index FAILED on first element.");
assert(TestEqAbs(itp.VectorToIndex(x1), size_t(nValues*nValues), size_t(0)) && "Test: Conversion vector --> index FAILED on last element.");
assert(TestEqAbs(itp.VectorToIndex((x1 - x0)/2.0f), size_t(nValues*nValues/2), size_t(0)) && "Test: Conversion vector --> index FAILED on the middle element.");
cout << " OK" << endl;
}*/
// Test - Zero-degree interpolation (R --> R)
{
cout << "\n\nTest: Zero-degree (nearest-neighbor/point sampling/Voronoi) interpolation:" << endl;
const string funcName = "TestFunc";
PrecompData<nValues> itp(funcName); // default: float type
itp.SetComment("TestFunc approximation");
const float x0 = 0.0f, x1 = 6.28f;
const float step = 0.5f*(x1 - x0)/nValues;
itp.Set(&TestFunc, x0, x1);
float x = x0;
float err = 0.0f;
itp.Interpolation(0);
cout << "Interpolation: " << itp.Interpolation() << endl;
for(int i = 0; i < nValues; ++i) {
const float y = itp(x);
err += fabs(TestFunc(x) - y);
cout << i << ":\t" << funcName << "(" << x << ") = " << TestFunc(x) << " ~ " << y << endl;
x += step;
}
cout << "Total error = " << err << endl;
}
// Test - Linear interpolation (R --> R)
{
cout << "\n\nTest: Linear interpolation:" << endl;
const string funcName = "TestFunc";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
const float step = 0.5f*(x1 - x0)/nValues;
itp.Set(&TestFunc, x0, x1);
float x = x0;
float err = 0.0f;
itp.Interpolation(1);
cout << "Interpolation: " << itp.Interpolation() << endl;
for(int i = 0; i < nValues; ++i) {
const float y = itp.Interpolate(x);
err += fabs(TestFunc(x) - y);
cout << i << ":\t" << funcName << "(" << x << ") = " << TestFunc(x) << " ~ " << y << endl;
x += step;
}
cout << "Total error = " << err << endl;
}
// Test - AutoSet (R --> R): y = 2x
{
cout << "\n\nTest: Automatic irregular grid: y = 2x" << endl;
const string funcName = "y = 2x";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.AutoSet(&TestFuncLin, x0, x1);
cerr << "x0 = " << x0 << " x1 = " << x1 << " nValues = " << nValues << endl; //+T+
std::vector<float> vx, vy;
itp.Get(vx, vy);
cout << "Sizes: x = " << vx.size() << "; y = " << vy.size() << endl;
for(size_t i = 0; i < nValues; ++i) {
cout << i << ": " << vx[i] << ", " << vy[i] << endl;
}
}
// Test - AutoSet (R --> R): y = 1/(|x-2| + 0.1)
{
cout << "\n\nTest: Automatic irregular grid: y = 1/(|x-2| + 0.1)" << endl;
const string funcName = "y = 1/(|x-2| + 0.1)";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.AutoSet(&TestFuncNonLin2, x0, x1);
cerr << "x0 = " << x0 << " x1 = " << x1 << " nValues = " << nValues << endl; //+T+
std::vector<float> vx, vy;
itp.Get(vx, vy);
cout << "Sizes: x = " << vx.size() << "; y = " << vy.size() << endl;
for(size_t i = 0; i < nValues; ++i) {
cout << i << ": " << vx[i] << ", " << vy[i] << endl;
}
}
// Test - Derivatives
{
cout << "\n\nTest: Derivatives" << endl;
int nTests = 0, nFailed = 0;
const string funcName = "Derivatives";
float x1, y1, x2, y2, x3, y3, der1, der2, expRes;
PrecompData<nValues, float> test;
// First derivative
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 0.0; expRes = 0.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 1" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 1.0; expRes = 1.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 2" << endl;
}
x1 = 1.0; y1 = 0.0; x2 = 0.0; y2 = 1.0; expRes = -1.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 3" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 2.0; y2 = 1.0; expRes = 0.5;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 4" << endl;
}
x1 = 0.0; y1 = -1.0; x2 = 1.0; y2 = 1.0; expRes = 2.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 5" << endl;
}
x1 = 0.0; y1 = 1.0; x2 = 1.0; y2 = 1.0; expRes = 0.0;
der1 = test.FirstDerivative(x1, y1, x2, y2);
++nTests;
if(fabs(der1 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - First derivative 6" << endl;
}
// Second derivative
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 0.0; x3 = 2.0; y3 = 0.0; expRes = 0.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 1" << endl;
}
x1 = 0.0; y1 = 1.0; x2 = 1.0; y2 = 1.0; x3 = 2.0; y3 = 1.0; expRes = 0.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 2" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 1.0; x3 = 2.0; y3 = 2.0; expRes = 0.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 3" << endl;
}
x1 = 0.0; y1 = 0.0; x2 = 1.0; y2 = 1.0; x3 = 2.0; y3 = 4.0; expRes = 2.0;
der2 = test.SecondDerivative(x1, y1, x2, y2, x3, y3);
++nTests;
if(fabs(der2 - expRes) > 0.0001f) {
++nFailed;
cerr << "Error - Second derivative 4: Result = " << der2 << "; Expected = " << expRes << endl;
}
cout << "Derivatives: Number of tests = " << nTests << "; Number of failures = " << nFailed << endl;
}
// Test - AutoSet: y = sin(x)
// Result: values too concentrated in the points with high absolute second derivative
{
cout << "\n\nTest: Automatic irregular grid: y = sin(x)" << endl;
const string funcName = "y = sin(x)";
PrecompData<nValues, float> itp(funcName);
const float x0 = 0.0f, x1 = 6.28f;
itp.SetOversampling(1.5f);
itp.AutoSet(&TestFuncNonLinSin, x0, x1);
cerr << "x0 = " << x0 << " x1 = " << x1 << " nValues = " << nValues << endl; //+T+
std::vector<float> vx, vy;
itp.Get(vx, vy);
cout << "Sizes: x = " << vx.size() << "; y = " << vy.size() << endl;
for(size_t i = 0; i < nValues; ++i) {
cout << i << ": " << vx[i] << ", " << vy[i] << endl;
}
int n = 100;
cout << "Compare approximation with real sin(x) function (done on " << n << " points):" << endl;
float error = 0.0f, avgErr = 0.0f;
float minErrX = 1.0e20f, minErrY = 1.0e20f;
float maxErrX = 0.0f, maxErrY = 0.0f;
float x = x0, step = (x1 - x0)/n;
for(int i = 0; i < n; ++i) {
error = fabs(sin(x) - itp.Interpolate(x));
cout << i << ": \t" << x << ", \t " << sin(x) << ", \t " << itp.Interpolate(x) << ", \t " << error << endl;
if(error < minErrY) { minErrX = x; minErrY = error; }
if(error > maxErrY) { maxErrX = x; maxErrY = error; }
avgErr += error;
x += step;
}
avgErr /= n;
cout << "Result: minimum error = [" << minErrX << ", " << minErrY
<< "]; maximum error = [" << maxErrX << ", " << maxErrY
<< "]; average error = " << avgErr << endl;
}
// Test - Multidimensions: Storage of data in an NxM space
{
cout << "\n\nTest: Storage of data in an NxM space:" << endl;
const string funcName = "Multidimensions";
pcd12 itp(funcName);
itp.SetComment("Y = f(X) X = x(i,j), Y = y(i)");
pcd12::X x0 = { { 0.00f, 0.00f } }; // coordinates of the starting point
pcd12::X x1 = { { 6.28f, 6.28f } }; // coordinates of the end point
const pcd12::X step = { { 0.5f*(x1[0] - x0[0])/nValues,
0.5f*(x1[1] - x0[1])/nValues } };
itp.Set(&TestFunc12, x0, x1, nValues*nValues);
pcd12::X x = x0;
float err = 0.0f;
for(int j = 0; j < nValues; ++j)
{
x[0] = x0[0];
for(int i = 0; i < nValues; ++i)
{
const pcd12::Y y = itp(x); //+B
err += fabs(TestFunc12(x)[0] - y[0]);
cout << i << ":\t" << funcName << "[" << x[0] << ", " << x[1] << "] = " << TestFunc12(x)[0] << " ~ " << y[0] << endl;
x[0] += step[0];
}
x[1] += step[1];
}
cout << "Total error = " << err << endl;
}
}
} // Utilities
int main()
{
using namespace Utilities;
PrecompData_test test;
return 0;
}
|
/*******************************************************************************
FILE : node_tool.c
LAST MODIFIED : 28 October 2004
DESCRIPTION :
Functions for mouse controlled node position and vector editing based on
Scene input.
==============================================================================*/
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is cmgui.
*
* The Initial Developer of the Original Code is
* Auckland Uniservices Ltd, Auckland, New Zealand.
* Portions created by the Initial Developer are Copyright (C) 2005
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
extern "C" {
#include <math.h>
#if defined (MOTIF)
#include <Xm/Protocols.h>
#include <Xm/MwmUtil.h>
#include <Xm/Xm.h>
#include <Xm/ToggleBG.h>
#include "choose/choose_computed_field.h"
#endif /* defined (MOTIF) */
#include "computed_field/computed_field.h"
#include "computed_field/computed_field_composite.h"
#include "computed_field/computed_field_finite_element.h"
#include "computed_field/computed_field_wrappers.h"
#include "general/debug.h"
#include "general/matrix_vector.h"
#include "general/mystring.h"
#include "graphics/element_group_settings.h"
#include "graphics/graphical_element.h"
#include "graphics/graphics_object.h"
#include "help/help_interface.h"
#include "interaction/interaction_graphics.h"
#include "interaction/interaction_volume.h"
#include "interaction/interactive_event.h"
#include "node/node_operations.h"
#include "node/node_tool.h"
#include "finite_element/finite_element.h"
#if defined (MOTIF)
static char node_tool_uidh[] =
#include "node/node_tool.uidh"
;
#include "motif/image_utilities.h"
#include "region/cmiss_region_chooser.h"
#endif /* defined (MOTIF) */
#include "region/cmiss_region.h"
#include "user_interface/gui_dialog_macros.h"
#include "user_interface/message.h"
}
#if defined (WX_USER_INTERFACE)
#include "wx/wx.h"
#include <wx/tglbtn.h>
#include "wx/xrc/xmlres.h"
#include "choose/choose_manager_class.hpp"
#include "graphics/graphics_window_private.hpp"
#include "node/node_tool.xrch"
#include "region/cmiss_region_chooser_wx.hpp"
#endif /* defined (WX_USER_INTERFACE)*/
/*
Module variables
----------------
*/
#if defined (MOTIF)
static int node_tool_hierarchy_open=0;
static MrmHierarchy node_tool_hierarchy;
#endif /* defined (MOTIF) */
static char Interactive_tool_node_type_string[] = "node_tool";
/*
Module types
------------
*/
#if defined (WX_USER_INTERFACE)
class wxNodeTool;
#endif /* defined (WX_USER_INTERFACE) */
struct Node_tool
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Object storing all the parameters for converting scene input messages into
changes in node position and derivatives etc.
==============================================================================*/
{
struct Execute_command *execute_command;
struct MANAGER(Interactive_tool) *interactive_tool_manager;
struct Interactive_tool *interactive_tool;
/* flag indicating that the above manager is actually the data manager */
int use_data;
/* The root region */
struct Cmiss_region *root_region;
/* The region we are working in */
struct Cmiss_region *region;
struct FE_region *fe_region;
/* needed for destroy button */
struct MANAGER(FE_element) *element_manager;
struct FE_node_selection *node_selection;
struct Computed_field_package *computed_field_package;
struct Graphical_material *rubber_band_material;
struct Time_keeper *time_keeper;
struct User_interface *user_interface;
/* user-settable flags */
/* indicates whether node edits can occur with motion_notify events: slower */
int motion_update_enabled;
/* indicates whether existing nodes can be selected */
int select_enabled;
/* indicates whether selected nodes can be edited */
int edit_enabled;
/* indicates whether new fields can be defined at nodes */
int define_enabled;
/* indicates whether new nodes will can be created */
int create_enabled;
/* if create_enabled, controls if create will be streaming, ie. creating
a stream of nodes where the user swipes, rather than just 1 */
int streaming_create_enabled;
/* if create is enabled this option will force the nodes to be created on a surface
rather than between near and far */
int constrain_to_surface;
enum Node_tool_edit_mode edit_mode;
struct Computed_field *coordinate_field, *command_field, *element_xi_field;
/* information about picked nodes the editor knows about */
struct Scene_picked_object *scene_picked_object;
struct FE_node *last_picked_node;
int picked_node_was_unselected;
int motion_detected;
struct GT_element_group *gt_element_group;
struct GT_element_settings *gt_element_settings;
struct Interaction_volume *last_interaction_volume;
struct GT_object *rubber_band;
struct FE_field *FE_coordinate_field;
/* maintain a template node for creating new nodes */
/* the dimension of the elements being created - user settable */
int element_dimension;
/* maintain template element for creating new elements */
struct FE_element *template_element;
/* indicates whether elements are created in response to node selections */
int element_create_enabled;
/* the element being created */
struct FE_element *element;
/* number of nodes that have been set in the element being created */
int number_of_clicked_nodes;
#if defined (MOTIF)
Display *display;
struct Cmiss_region_chooser *cmiss_region_chooser;
Widget coordinate_field_form,coordinate_field_widget,create_button,
constrain_to_surface_button,define_button,edit_button,
motion_update_button,node_group_form,node_group_widget,select_button,
streaming_create_button,command_field_button,command_field_form,
command_field_widget;
Widget widget,window_shell;
#else /* defined (MOTIF) */
/* without cmiss_region_chooser need somewhere to store the region path */
char *current_region_path;
#endif /* defined (MOTIF) */
#if defined (WX_USER_INTERFACE)
wxNodeTool *wx_node_tool;
struct MANAGER(Computed_field) *computed_field_manager;
wxPoint tool_position;
#endif /* defined (WX_USER_INTERFACE) */
}; /* struct Node_tool */
struct FE_node_edit_information
/*******************************************************************************
LAST MODIFIED : 19 February 2008
DESCRIPTION :
Describes how to move a node in space. The node will move on the plane normal
to the viewing direction a distance proportional to the two starting and
finishing points on the near and far plane. The exact amount is in proportion
to its position between these two planes.
==============================================================================*/
{
/* the actual coordinate change calculated from the drag at the last picked
node */
double delta1,delta2,delta3;
/* the current value of the time being used */
FE_value time;
/* the gesture indicated by the mouse is given by initial and final
interaction volumes */
struct Interaction_volume *final_interaction_volume,
*initial_interaction_volume;
/* the field to translate */
struct Computed_field *coordinate_field;
/* The same field wrapped to get RC coordinates */
struct Computed_field *rc_coordinate_field;
/* following required for EDIT_VECTOR only */
struct Computed_field *orientation_scale_field,
*wrapper_orientation_scale_field, *variable_scale_field;
Triple glyph_centre, glyph_scale_factors, glyph_size;
/* editing nodes in this region */
struct FE_region *fe_region;
/* information for undoing scene object transformations - only needs to be
done if transformation_required is set */
int transformation_required,LU_indx[4];
double transformation_matrix[16],LU_transformation_matrix[16];
/* The last_picked node is used to calculate the delta change and so when
the whole active group is looped over this node is ignored */
struct FE_node *last_picked_node;
/* Fields that allow constrain_to_surface to work correctly,
only the last picked node will be updated as this is the only one
we know the element for */
int constrain_to_surface;
struct FE_element *nearest_element;
struct Computed_field *nearest_element_coordinate_field;
struct Computed_field *element_xi_field;
}; /* struct FE_node_edit_information */
struct Node_tool_element_constraint_function_data
{
struct FE_element *element, *found_element;
FE_value xi[MAXIMUM_ELEMENT_XI_DIMENSIONS];
struct Computed_field *coordinate_field;
}; /* struct Node_tool_element_constraint_function_data */
/*
Module functions
----------------
*/
#if defined (MOTIF)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,coordinate_field_form)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,create_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,constrain_to_surface_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,define_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,edit_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,motion_update_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,node_group_form)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,select_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,streaming_create_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,command_field_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,command_field_form)
#endif /* defined (MOTIF) */
/* Prototype */
#if defined (WX_USER_INTERFACE)
static int Node_tool_end_element_creation(
struct Node_tool *node_tool);
#endif /*defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_create_enabled(struct Node_tool *node_tool,
int create_enabled);
#endif /*defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_dimension(
struct Node_tool *node_tool,int element_dimension);
#endif /*defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
static int Node_tool_refresh_element_dimension_text(
struct Node_tool *node_tool);
#endif /*defined (WX_USER_INTERFACE)*/
static int Node_tool_define_field_at_node(struct Node_tool *node_tool,
struct FE_node *node)
/*******************************************************************************
LAST MODIFIED : 16 October 2001
DESCRIPTION :
Defines the appropriate FE_field upon which the <coordinate_field> depends in
<node>. The field is defined with no versions or derivatives.
==============================================================================*/
{
int return_code;
struct FE_field *fe_field;
struct FE_node_field_creator *node_field_creator;
struct LIST(FE_field) *fe_field_list;
ENTER(Node_tool_define_field_at_node);
if (node_tool && node)
{
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list))&&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)) && (3 >= get_FE_field_number_of_components(
fe_field)) && (FE_VALUE_VALUE == get_FE_field_value_type(fe_field)))
{
if (node_field_creator = CREATE(FE_node_field_creator)(
/*number_of_components*/3))
{
if (define_FE_field_at_node(node,fe_field,
(struct FE_time_sequence *)NULL,
node_field_creator))
{
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Failed");
return_code=0;
}
DESTROY(FE_node_field_creator)(&node_field_creator);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Unable to make creator.");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Invalid field");
return_code=0;
}
DESTROY(LIST(FE_field))(&fe_field_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. No field to define");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_define_field_at_node */
static int FE_node_define_and_set_element_xi(struct FE_node *node,
struct Computed_field *element_xi_field,
struct FE_element *element, FE_value *xi)
/*******************************************************************************
LAST MODIFIED : 19 February 2008
DESCRIPTION :
Defines element_xi_field at node if not already defined. Sets value.
==============================================================================*/
{
int return_code;
struct FE_field *fe_field;
struct FE_node_field_creator *node_field_creator;
ENTER(FE_node_define_and_set_element_xi);
return_code = 0;
if (node && element_xi_field && element && xi)
{
fe_field = (struct FE_field *)NULL;
if (Computed_field_get_type_finite_element(element_xi_field, &fe_field))
{
if (!FE_field_is_defined_at_node(fe_field,node))
{
if (node_field_creator =
CREATE(FE_node_field_creator)(/*number_of_components*/1))
{
define_FE_field_at_node(node, fe_field,
(struct FE_time_sequence *)NULL, node_field_creator);
DESTROY(FE_node_field_creator)(&node_field_creator);
}
}
return_code = set_FE_nodal_element_xi_value(node,fe_field,/*component_number*/0,
/*version*/0,FE_NODAL_VALUE,element,xi);
}
if (!return_code)
{
display_message(ERROR_MESSAGE,
"FE_node_define_and_set_element_xi. Failed");
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_define_and_set_element_xi. Invalid argument(s)");
}
LEAVE;
return (return_code);
} /* FE_node_define_and_set_element_xi */
static int model_to_world_coordinates(FE_value coordinates[3],
double *transformation_matrix)
/*******************************************************************************
LAST MODIFIED : 23 July 1999
DESCRIPTION :
Makes a homogoneous coordinate [x,y,z,1] out of <coordinates> and premultiplies
it by the 16 value 4x4 <transformation_matrix> to give [x',y',z',h']. If h' is
non-zero the <coordinates> are modified to [x'/h',y'/h',z'/h'], otherwise an
error is reported.
==============================================================================*/
{
double h,model_coordinates[4],world_coordinates[4];
int return_code;
ENTER(model_to_world_coordinates);
if (coordinates&&transformation_matrix)
{
model_coordinates[0]=(double)coordinates[0];
model_coordinates[1]=(double)coordinates[1];
model_coordinates[2]=(double)coordinates[2];
model_coordinates[3]=1.0;
if (multiply_matrix(4,4,1,transformation_matrix,
model_coordinates,world_coordinates)&&
(0.0 != (h=world_coordinates[3])))
{
coordinates[0]=(FE_value)(world_coordinates[0] / h);
coordinates[1]=(FE_value)(world_coordinates[1] / h);
coordinates[2]=(FE_value)(world_coordinates[2] / h);
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"model_to_world_coordinates. Invalid transformation");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"model_to_world_coordinates. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* model_to_world_coordinates */
static int world_to_model_coordinates(FE_value coordinates[3],
double *LU_transformation_matrix,int *LU_indx)
/*******************************************************************************
LAST MODIFIED : 23 July 1999
DESCRIPTION :
Makes a homogoneous coordinate [x',y',z',1] out of <coordinates> and solves for
the homogeneous model_coordinates [x,y,z,h] using the already-decomposed
16 value 4x4 <LU_transformation_matrix> and associated 4 value <LU_indx> vector.
If h is non-zero the <coordinates> are modified to [x/h,y/h,z/h], otherwise an
error is reported.
==============================================================================*/
{
double h,model_coordinates[4];
int return_code;
ENTER(world_to_model_coordinates);
if (coordinates&&LU_transformation_matrix)
{
model_coordinates[0]=(double)coordinates[0];
model_coordinates[1]=(double)coordinates[1];
model_coordinates[2]=(double)coordinates[2];
model_coordinates[3]=1.0;
if (LU_backsubstitute(4,LU_transformation_matrix,LU_indx,
model_coordinates)&&(0.0 != (h=model_coordinates[3],/*singular_tolerance*/1.0e-12)))
{
coordinates[0]=(FE_value)(model_coordinates[0] / h);
coordinates[1]=(FE_value)(model_coordinates[1] / h);
coordinates[2]=(FE_value)(model_coordinates[2] / h);
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"world_to_model_coordinates. Invalid transformation");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"world_to_model_coordinates. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* world_to_model_coordinates */
static int Node_tool_element_constraint_function(FE_value *point,
void *void_data)
/*******************************************************************************
LAST MODIFIED : 14 February 2008
DESCRIPTION :
==============================================================================*/
{
int return_code;
struct Node_tool_element_constraint_function_data *data;
ENTER(Node_tool_element_constraint_function_data);
if (point && (data = (struct Node_tool_element_constraint_function_data *)void_data))
{
data->found_element = data->element;
return_code = Computed_field_find_element_xi(data->coordinate_field,
point, /*number_of_values*/3, &(data->found_element),
data->xi, /*element_dimension*/2,
(struct Cmiss_region *)NULL, /*propagate_field*/0, /*find_nearest_location*/1);
Computed_field_evaluate_in_element(data->coordinate_field,
data->found_element, data->xi, /*time*/0.0, (struct FE_element *)NULL,
point, (FE_value *)NULL);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_element_constraint_function. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_element_constraint_function */
static int FE_node_calculate_delta_position(struct FE_node *node,
void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 27 April 2000
DESCRIPTION :
Calculates the delta change in the coordinates due to the ray supplied in the
<edit_info>. This change is set inside the <edit_info> and this can then be
applied to multiple nodes.
==============================================================================*/
{
double model_coordinates[3],normalised_coordinates[3],placement_coordinates[3];
FE_value coordinates[3], initial_coordinates[3], final_coordinates[3];
int i, return_code;
struct FE_node_edit_information *edit_info;
struct Node_tool_element_constraint_function_data constraint_data;
ENTER(FE_node_calculate_delta_position);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->rc_coordinate_field&&
(3>=Computed_field_get_number_of_components(
edit_info->rc_coordinate_field)))
{
return_code=1;
/* clear coordinates in case less than 3 dimensions */
coordinates[0]=0.0;
coordinates[1]=0.0;
coordinates[2]=0.0;
if (Computed_field_evaluate_at_node(edit_info->rc_coordinate_field,
node,edit_info->time,coordinates))
{
initial_coordinates[0] = coordinates[0];
initial_coordinates[1] = coordinates[1];
initial_coordinates[2] = coordinates[2];
if (edit_info->transformation_required)
{
return_code=model_to_world_coordinates(coordinates,
edit_info->transformation_matrix);
}
if (return_code)
{
if (edit_info->constrain_to_surface && edit_info->nearest_element &&
edit_info->nearest_element_coordinate_field)
{
constraint_data.element = edit_info->nearest_element;
constraint_data.found_element = edit_info->nearest_element;
constraint_data.coordinate_field = edit_info->nearest_element_coordinate_field;
for (i = 0; i < MAXIMUM_ELEMENT_XI_DIMENSIONS; i++)
{
constraint_data.xi[i] = 0.5;
}
Interaction_volume_get_placement_point(edit_info->final_interaction_volume,
placement_coordinates, Node_tool_element_constraint_function,
&constraint_data);
coordinates[0] = placement_coordinates[0];
coordinates[1] = placement_coordinates[1];
coordinates[2] = placement_coordinates[2];
}
else
{
/* convert initial model coordinates into normalised coordinates in the
space of the initial_interaction_volume, and back into model
coordinates in the space of the final_interaction_volume to get
translation of node */
model_coordinates[0]=(double)coordinates[0];
model_coordinates[1]=(double)coordinates[1];
model_coordinates[2]=(double)coordinates[2];
return_code=Interaction_volume_model_to_normalised_coordinates(
edit_info->initial_interaction_volume,model_coordinates,
normalised_coordinates)&&
Interaction_volume_normalised_to_model_coordinates(
edit_info->final_interaction_volume,normalised_coordinates,
model_coordinates);
coordinates[0]=(FE_value)model_coordinates[0];
coordinates[1]=(FE_value)model_coordinates[1];
coordinates[2]=(FE_value)model_coordinates[2];
}
}
if (return_code&&edit_info->transformation_required)
{
return_code=world_to_model_coordinates(coordinates,
edit_info->LU_transformation_matrix,edit_info->LU_indx);
}
if (return_code)
{
edit_info->last_picked_node = node;
if (edit_info->coordinate_field != edit_info->rc_coordinate_field)
{
/* get delta of coordinate_field from change of rc_coordinate_field */
return_code=Computed_field_evaluate_at_node(
edit_info->coordinate_field,node,edit_info->time,
initial_coordinates)&&
Computed_field_set_values_at_node(
edit_info->rc_coordinate_field,node,edit_info->time,
coordinates)&&
Computed_field_evaluate_at_node(edit_info->coordinate_field,
node,edit_info->time,final_coordinates);
edit_info->delta1 = final_coordinates[0] - initial_coordinates[0];
edit_info->delta2 = final_coordinates[1] - initial_coordinates[1];
edit_info->delta3 = final_coordinates[2] - initial_coordinates[2];
}
else
{
edit_info->delta1 = coordinates[0] - initial_coordinates[0];
edit_info->delta2 = coordinates[1] - initial_coordinates[1];
edit_info->delta3 = coordinates[2] - initial_coordinates[2];
return_code=Computed_field_set_values_at_node(
edit_info->rc_coordinate_field,node,edit_info->time,
coordinates);
}
/* may be some application for not editing element_xi field value */
if (return_code && edit_info->nearest_element &&
constraint_data.found_element && edit_info->element_xi_field)
{
return_code = FE_node_define_and_set_element_xi(node,
edit_info->element_xi_field, constraint_data.found_element,
constraint_data.xi);
}
}
}
else
{
return_code=0;
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->rc_coordinate_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_position. Failed");
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_position. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_calculate_delta_position */
static int FE_node_edit_position(struct FE_node *node,void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 15 September 2000
DESCRIPTION :
Translates the <rc_coordinate_field> of <node> according to the delta change
stored in the <edit_info>.
==============================================================================*/
{
FE_value coordinates[3];
int return_code;
struct FE_node_edit_information *edit_info;
ENTER(FE_node_edit_position);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->rc_coordinate_field&&
(3>=Computed_field_get_number_of_components(
edit_info->rc_coordinate_field)))
{
return_code=1;
/* the last_picked_node was edited in FE_node_calculate_delta_position.
Also, don't edit unless in node_group, if supplied */
if ((node != edit_info->last_picked_node)&&(
FE_region_contains_FE_node(edit_info->fe_region, node)))
{
/* clear coordinates in case less than 3 dimensions */
coordinates[0]=0.0;
coordinates[1]=0.0;
coordinates[2]=0.0;
/* If the field we are changing isn't defined at this node then we
don't complain and just do nothing */
if (Computed_field_is_defined_at_node(edit_info->coordinate_field,node)&&
Computed_field_evaluate_at_node(edit_info->coordinate_field,
node,edit_info->time,coordinates))
{
if (return_code)
{
coordinates[0] += edit_info->delta1;
coordinates[1] += edit_info->delta2;
coordinates[2] += edit_info->delta3;
if (!Computed_field_set_values_at_node(edit_info->coordinate_field,
node,edit_info->time, coordinates))
{
return_code=0;
}
}
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->coordinate_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,"FE_node_edit_position. Failed");
}
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_edit_position. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_edit_position */
static int FE_node_calculate_delta_vector(struct FE_node *node,
void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 20 November 2000
DESCRIPTION :
Moves the end of the vector to exactly under the mouse, in the plane normal to the view direction at its current depth. Hence, this function should only be
called for a single node.
Note that you must supply an orientation_scale field, while glyph_size[0] and
glyph_centre[0] must be 0.0, and glyph_scale_factors[0] must be non-zero.
NOTE: currently does not tolerate having a variable_scale_field.
==============================================================================*/
{
double model_coordinates[3],normalised_coordinates[3];
FE_value a[3],b[3],c[3],coordinates[3],end_coordinates[3],old_coordinates[3],
orientation_scale[9],scale_factor;
int number_of_orientation_scale_components,return_code;
struct FE_node_edit_information *edit_info;
Triple size;
ENTER(FE_node_calculate_delta_vector);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->rc_coordinate_field&&
(3>=Computed_field_get_number_of_components(
edit_info->rc_coordinate_field))&&
edit_info->wrapper_orientation_scale_field&&
(0<(number_of_orientation_scale_components=
Computed_field_get_number_of_components(
edit_info->wrapper_orientation_scale_field)))&&
(9>=number_of_orientation_scale_components)&&
(0.0 == edit_info->glyph_centre[0])&&
(0.0 == edit_info->glyph_size[0])&&
(0.0 != (scale_factor=edit_info->glyph_scale_factors[0])) &&
((struct Computed_field *)NULL == edit_info->variable_scale_field))
{
return_code=1;
/* clear coordinates in case less than 3 dimensions */
coordinates[0]=0.0;
coordinates[1]=0.0;
coordinates[2]=0.0;
if (Computed_field_evaluate_at_node(
edit_info->wrapper_orientation_scale_field,node,edit_info->time,
orientation_scale)&&
Computed_field_evaluate_at_node(edit_info->rc_coordinate_field,
node,edit_info->time,coordinates)&&
make_glyph_orientation_scale_axes(number_of_orientation_scale_components,
orientation_scale, a, b, c, size))
{
/* save old coordinates since will not change when converted back to
model coordinates */
old_coordinates[0]=coordinates[0];
old_coordinates[1]=coordinates[1];
old_coordinates[2]=coordinates[2];
end_coordinates[0]=coordinates[0]+size[0]*scale_factor*a[0];
end_coordinates[1]=coordinates[1]+size[0]*scale_factor*a[1];
end_coordinates[2]=coordinates[2]+size[0]*scale_factor*a[2];
if (edit_info->transformation_required)
{
return_code=model_to_world_coordinates(coordinates,
edit_info->transformation_matrix)&&
model_to_world_coordinates(end_coordinates,
edit_info->transformation_matrix);
}
if (return_code)
{
/* convert end_coordinates into normalised coordinates in the
space of the initial_interaction_volume, and back into model
coordinates centred in the space of the final_interaction_volume to
get new end point */
model_coordinates[0]=(double)end_coordinates[0];
model_coordinates[1]=(double)end_coordinates[1];
model_coordinates[2]=(double)end_coordinates[2];
return_code=Interaction_volume_model_to_normalised_coordinates(
edit_info->initial_interaction_volume,model_coordinates,
normalised_coordinates)&&
Interaction_volume_centred_normalised_to_model_coordinates(
edit_info->final_interaction_volume,normalised_coordinates,
model_coordinates);
end_coordinates[0]=(FE_value)model_coordinates[0];
end_coordinates[1]=(FE_value)model_coordinates[1];
end_coordinates[2]=(FE_value)model_coordinates[2];
}
if (edit_info->transformation_required)
{
return_code=world_to_model_coordinates(end_coordinates,
edit_info->LU_transformation_matrix,edit_info->LU_indx);
}
if (return_code)
{
/* note use of old_coordinates in model space */
a[0]=(end_coordinates[0]-old_coordinates[0])/scale_factor;
a[1]=(end_coordinates[1]-old_coordinates[1])/scale_factor;
a[2]=(end_coordinates[2]-old_coordinates[2])/scale_factor;
switch (number_of_orientation_scale_components)
{
case 1:
{
/* scalar */
edit_info->delta1=orientation_scale[0]=a[0];
} break;
case 2:
case 4:
{
/* 1 or 2 2-D vectors */
edit_info->delta1=orientation_scale[0]=a[0];
edit_info->delta2=orientation_scale[1]=a[1];
} break;
case 3:
case 6:
case 9:
{
/* 1,2 or 3, 3-D vectors */
edit_info->delta1=orientation_scale[0]=a[0];
edit_info->delta2=orientation_scale[1]=a[1];
edit_info->delta3=orientation_scale[2]=a[2];
} break;
default:
{
display_message(ERROR_MESSAGE,"FE_node_calculate_delta_vector. "
"Invalid number of orientation scale components");
return_code=0;
} break;
}
}
if (return_code)
{
if (!Computed_field_set_values_at_node(
edit_info->wrapper_orientation_scale_field,node,edit_info->time,
orientation_scale))
{
return_code=0;
}
if (edit_info->orientation_scale_field !=
edit_info->wrapper_orientation_scale_field)
{
/* get delta values from the orientation_scale_field */
if (Computed_field_evaluate_at_node(
edit_info->orientation_scale_field,node,
edit_info->time,orientation_scale))
{
number_of_orientation_scale_components=
Computed_field_get_number_of_components(
edit_info->orientation_scale_field);
switch (number_of_orientation_scale_components)
{
case 1:
{
/* scalar */
edit_info->delta1=orientation_scale[0];
} break;
case 2:
case 4:
{
/* 1 or 2 2-D vectors */
edit_info->delta1=orientation_scale[0];
edit_info->delta2=orientation_scale[1];
} break;
case 3:
case 6:
case 9:
{
/* 1,2 or 3, 3-D vectors */
edit_info->delta1=orientation_scale[0];
edit_info->delta2=orientation_scale[1];
edit_info->delta3=orientation_scale[2];
} break;
default:
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_vector. "
"Invalid number of orientation scale components");
return_code=0;
} break;
}
}
else
{
return_code=0;
}
}
}
}
else
{
return_code=0;
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->rc_coordinate_field);
Computed_field_clear_cache(edit_info->wrapper_orientation_scale_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,"FE_node_calculate_delta_vector. Failed");
}
}
else
{
if ((0.0 != edit_info->glyph_centre[0]) ||
(0.0 != edit_info->glyph_size[0]) ||
(0.0 == (scale_factor=edit_info->glyph_scale_factors[0])))
{
if (0.0 != edit_info->glyph_centre[0])
{
display_message(ERROR_MESSAGE,
"To edit orientation vectors your main direction glyph centre must be zero.");
}
if (0.0 != edit_info->glyph_size[0])
{
display_message(ERROR_MESSAGE,
"To edit orientation vectors your main direction base glyph size must be zero.");
}
if (0.0 == (scale_factor=edit_info->glyph_scale_factors[0]))
{
display_message(ERROR_MESSAGE,
"To edit orientation vectors your main direction scale factor must not be zero.");
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_vector. Invalid argument(s)");
}
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_calculate_delta_vector */
static int FE_node_edit_vector(struct FE_node *node,void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 22 March 2000
DESCRIPTION :
Translates the <rc_coordinate_field> of <node> according to the delta change
stored in the <edit_info>.
==============================================================================*/
{
FE_value orientation_scale[9];
int number_of_orientation_scale_components,return_code;
struct FE_node_edit_information *edit_info;
ENTER(FE_node_edit_vector);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->orientation_scale_field&&
(0<(number_of_orientation_scale_components=
Computed_field_get_number_of_components(
edit_info->orientation_scale_field)))&&
(9>=number_of_orientation_scale_components))
{
return_code=1;
/* the last_picked_node was edited in FE_node_calculate_delta_vector. */
if ((node != edit_info->last_picked_node)&&(
FE_region_contains_FE_node(edit_info->fe_region, node)))
{
if (Computed_field_evaluate_at_node(
edit_info->orientation_scale_field,node,edit_info->time,
orientation_scale))
{
switch (number_of_orientation_scale_components)
{
case 1:
{
/* scalar */
orientation_scale[0]=edit_info->delta1;
} break;
case 2:
case 4:
{
/* 1 or 2 2-D vectors */
orientation_scale[0]=edit_info->delta1;
orientation_scale[1]=edit_info->delta2;
} break;
case 3:
case 6:
case 9:
{
/* 1,2 or 3, 3-D vectors */
orientation_scale[0]=edit_info->delta1;
orientation_scale[1]=edit_info->delta2;
orientation_scale[2]=edit_info->delta3;
} break;
default:
{
display_message(ERROR_MESSAGE,"FE_node_edit_vector. "
"Invalid number of orientation scale components");
return_code=0;
} break;
}
if (return_code)
{
if (!Computed_field_set_values_at_node(
edit_info->orientation_scale_field,node,edit_info->time,
orientation_scale))
{
return_code=0;
}
}
}
else
{
return_code=0;
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->orientation_scale_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,"FE_node_edit_vector. Failed");
}
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_edit_vector. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_edit_vector */
static int Node_tool_define_field_at_node_from_picked_coordinates(
struct Node_tool *node_tool,struct FE_node *node)
/*******************************************************************************
LAST MODIFIED : 29 September 2000
DESCRIPTION :
Defines the coordinate_field at the node using the position of the picked
object's coordinate field.
==============================================================================*/
{
FE_value coordinates[3], time;
int return_code;
struct Computed_field *coordinate_field, *picked_coordinate_field,
*rc_coordinate_field, *rc_picked_coordinate_field;
ENTER(Node_tool_define_field_at_node_from_picked_coordinates);
if (node_tool&&node)
{
coordinate_field=node_tool->coordinate_field;
if (node_tool->time_keeper)
{
time = Time_keeper_get_time(node_tool->time_keeper);
}
else
{
time = 0;
}
if (rc_coordinate_field=
Computed_field_begin_wrap_coordinate_field(coordinate_field))
{
if (!(picked_coordinate_field = GT_element_settings_get_coordinate_field(
node_tool->gt_element_settings)))
{
picked_coordinate_field = GT_element_group_get_default_coordinate_field(
node_tool->gt_element_group);
}
rc_picked_coordinate_field = Computed_field_begin_wrap_coordinate_field(
picked_coordinate_field);
if (Computed_field_evaluate_at_node(rc_picked_coordinate_field,
node,time,coordinates))
{
if (Node_tool_define_field_at_node(node_tool,node)&&
Computed_field_set_values_at_node(rc_coordinate_field,
node,time,coordinates))
{
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. Failed");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. "
"Unable to evaluate picked position.");
return_code=0;
}
Computed_field_clear_cache(rc_picked_coordinate_field);
Computed_field_end_wrap(&rc_picked_coordinate_field);
Computed_field_clear_cache(rc_coordinate_field);
Computed_field_end_wrap(&rc_coordinate_field);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. "
"Could not wrap coordinate field");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. "
"Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_define_field_at_node_from_picked_coordinates */
static struct FE_node *Node_tool_create_node_at_interaction_volume(
struct Node_tool *node_tool,struct Scene *scene,
struct Interaction_volume *interaction_volume,
struct FE_element *nearest_element, struct Computed_field *element_coordinate_field)
/*******************************************************************************
LAST MODIFIED : 14 February 2008
DESCRIPTION :
Returns a new node in the position indicated by <interaction_volume>, in the
<scene> if suppled. If any of the remaining address arguments
are not NULL, they are filled with the appropriate information pertaining to
the new node.
If <nearest_element> and <coordinate_field> are supplied then
the interaction volume will be supplied a constraint function which will
try to enforce that the node is created on that element.
==============================================================================*/
{
double d,LU_transformation_matrix[16],node_coordinates[3];
enum GT_element_settings_type gt_element_settings_type;
FE_value coordinates[3];
int i,LU_indx[4],node_number,transformation_required;
struct Computed_field *rc_coordinate_field,*node_tool_coordinate_field;
struct FE_node *merged_node, *node;
struct GT_element_group *gt_element_group;
struct GT_element_settings *gt_element_settings;
struct Node_tool_element_constraint_function_data constraint_data;
struct Scene_object *scene_object;
LIST_CONDITIONAL_FUNCTION(Scene_object) *scene_object_conditional_function;
struct Scene_picked_object *scene_picked_object;
ENTER(Node_tool_create_node_at_interaction_volume);
merged_node = (struct FE_node *)NULL;
scene_picked_object=(struct Scene_picked_object *)NULL;
gt_element_group=(struct GT_element_group *)NULL;
gt_element_settings=(struct GT_element_settings *)NULL;
if (!node_tool || !interaction_volume)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. Invalid argument(s)");
}
else
{
if (!node_tool->coordinate_field)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. No coordinate field to define");
}
else if (!node_tool->fe_region)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. No region chosen for new node");
}
else
{
node_tool_coordinate_field=node_tool->coordinate_field;
if (node_tool->use_data)
{
scene_object_conditional_function=Scene_object_has_data_Cmiss_region;
gt_element_settings_type=GT_ELEMENT_SETTINGS_DATA_POINTS;
}
else
{
scene_object_conditional_function=Scene_object_has_Cmiss_region;
gt_element_settings_type=GT_ELEMENT_SETTINGS_NODE_POINTS;
}
if (scene&&(scene_object=first_Scene_object_in_Scene_that(scene,
scene_object_conditional_function,(void *)node_tool->region)))
{
gt_element_group=Scene_object_get_graphical_element_group(scene_object);
gt_element_settings=first_settings_in_GT_element_group_that(
gt_element_group,GT_element_settings_type_matches,
(void *)gt_element_settings_type);
/* return a scene_object with the correct transformation */
if (scene_picked_object=CREATE(Scene_picked_object)(/*hit_no*/0))
{
Scene_picked_object_add_Scene_object(scene_picked_object,
scene_object);
REACCESS(Scene_picked_object)(&(node_tool->scene_picked_object),
scene_picked_object);
}
}
else
{
scene_picked_object=(struct Scene_picked_object *)NULL;
}
if (rc_coordinate_field=
Computed_field_begin_wrap_coordinate_field(node_tool_coordinate_field))
{
node_number = FE_region_get_next_FE_node_identifier(
node_tool->fe_region, /*start*/1);
/* get new node coordinates from interaction_volume */
if (nearest_element && element_coordinate_field)
{
constraint_data.element = nearest_element;
constraint_data.found_element = nearest_element;
constraint_data.coordinate_field = element_coordinate_field;
for (i = 0; i < MAXIMUM_ELEMENT_XI_DIMENSIONS; i++)
{
constraint_data.xi[i] = 0.5;
}
Interaction_volume_get_placement_point(interaction_volume,
node_coordinates, Node_tool_element_constraint_function,
&constraint_data);
}
else
{
Interaction_volume_get_placement_point(interaction_volume,
node_coordinates, (Interation_volume_constraint_function)NULL,
(void *)NULL);
}
for (i=0;i<3;i++)
{
coordinates[i]=(FE_value)node_coordinates[i];
}
if (scene_picked_object&&
Scene_picked_object_get_total_transformation_matrix(
node_tool->scene_picked_object,&transformation_required,
LU_transformation_matrix)&&transformation_required&&
LU_decompose(4,LU_transformation_matrix,LU_indx,&d,/*singular_tolerance*/1.0e-12))
{
world_to_model_coordinates(coordinates,
LU_transformation_matrix,LU_indx);
}
node = CREATE(FE_node)(node_number, node_tool->fe_region, /*template*/(struct FE_node *)NULL);
if (!node)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. Could not create node");
}
else
{
ACCESS(FE_node)(node);
if (!Node_tool_define_field_at_node(node_tool,node) ||
!Computed_field_set_values_at_node(rc_coordinate_field, node,
/*time*/0, coordinates) ||
(nearest_element && constraint_data.found_element && node_tool->element_xi_field &&
!FE_node_define_and_set_element_xi(node, node_tool->element_xi_field,
constraint_data.found_element, constraint_data.xi)) ||
(NULL == (merged_node =
FE_region_merge_FE_node(node_tool->fe_region, node))))
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. Could not define and set fields");
}
DEACCESS(FE_node)(&node);
}
Computed_field_clear_cache(rc_coordinate_field);
Computed_field_end_wrap(&rc_coordinate_field);
}
}
}
if (node_tool)
{
/* only need following if editing; in which case need all of them */
if ((!merged_node) || (!scene_picked_object) || (!gt_element_group) ||
(!gt_element_settings))
{
scene_picked_object=(struct Scene_picked_object *)NULL;
gt_element_group=(struct GT_element_group *)NULL;
gt_element_settings=(struct GT_element_settings *)NULL;
}
/* make sure node_tool point at following as found out above */
REACCESS(Scene_picked_object)(&(node_tool->scene_picked_object),
scene_picked_object);
REACCESS(GT_element_group)(&(node_tool->gt_element_group),
gt_element_group);
REACCESS(GT_element_settings)(&(node_tool->gt_element_settings),
gt_element_settings);
}
LEAVE;
return (merged_node);
} /* Node_tool_create_node_at_interaction_volume */
static int Node_tool_set_Cmiss_region(struct Node_tool *node_tool,
struct Cmiss_region *region)
/*******************************************************************************
LAST MODIFIED : 20 March 2003
DESCRIPTION :
Sets the <region> used by <node_tool>.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_Cmiss_region);
if (node_tool)
{
return_code=1;
if (region != node_tool->region)
{
node_tool->region = region;
if (region)
{
node_tool->fe_region = Cmiss_region_get_FE_region(region);
}
else
{
node_tool->fe_region = (struct FE_region *)NULL;
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_Cmiss_region. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_Cmiss_region */
#if defined (MOTIF)
static void Node_tool_close_CB(Widget widget,void *node_tool_void,
void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback when "close" is selected from the window menu, or it is double
clicked. How this is made to occur is as follows. The dialog has its
XmNdeleteResponse == XmDO_NOTHING, and a window manager protocol callback for
WM_DELETE_WINDOW has been set up with XmAddWMProtocolCallback to call this
function in response to the close command. See CREATE for more details.
Function pops down dialog as a response,
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_close_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
XtPopdown(node_tool->window_shell);
}
else
{
display_message(ERROR_MESSAGE,"Node_tool_close_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_close_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_create_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether nodes are created in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_create_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_create_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_create_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_create_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_define_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 11 September 2000
DESCRIPTION :
Callback from toggle button controlling whether fields are defined at nodes in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_define_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_define_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_define_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_edit_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether nodes are edited in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_edit_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_edit_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_edit_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_edit_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_motion_update_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether editing motions are updated
during the edit - if off then updates only once at the end.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_motion_update_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_motion_update_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_motion_update_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_motion_update_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_select_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether nodes are selected in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_select_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_select_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_select_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_select_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_streaming_create_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 14 May 2001
DESCRIPTION :
Callback from toggle button controlling whether nodes are created continuously,
ie. streaming in response to interactive events = user drags.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_streaming_create_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_streaming_create_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_streaming_create_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_streaming_create_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_constrain_to_surface_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 April 2005
DESCRIPTION :
Callback from toggle button controlling whether nodes are created on surface
elements or just halfway between near and far.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_constrain_to_surface_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_constrain_to_surface(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_constrain_to_surface_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_constrain_to_surface_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_command_field_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Callback from toggle button enabling a command_field to be selected.
==============================================================================*/
{
struct Computed_field *command_field;
struct Node_tool *node_tool;
ENTER(Node_tool_command_field_button_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (Node_tool_get_command_field(node_tool))
{
Node_tool_set_command_field(node_tool, (struct Computed_field *)NULL);
}
else
{
/* get label field from widget */
command_field = CHOOSE_OBJECT_GET_OBJECT(Computed_field)(
node_tool->command_field_widget);
if (command_field)
{
Node_tool_set_command_field(node_tool, command_field);
}
else
{
XtVaSetValues(node_tool->command_field_button, XmNset, False, NULL);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_command_field_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_command_field_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_update_command_field(Widget widget,
void *node_tool_void, void *command_field_void)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Callback for change of command_field.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_update_command_field);
USE_PARAMETER(widget);
if (node_tool = (struct Node_tool *)node_tool_void)
{
/* skip messages from chooser if it is grayed out */
if (XtIsSensitive(node_tool->command_field_widget))
{
Node_tool_set_command_field(node_tool,
(struct Computed_field *)command_field_void);
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_update_command_field. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_update_command_field */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_update_region(Widget widget,
void *node_tool_void,void *region_void)
/*******************************************************************************
LAST MODIFIED : 23 January 2003
DESCRIPTION :
Callback for change of region that we are working in.
==============================================================================*/
{
struct Cmiss_region *region;
struct Node_tool *node_tool;
ENTER(Node_tool_update_region);
USE_PARAMETER(widget);
if (node_tool=(struct Node_tool *)node_tool_void)
{
region = (struct Cmiss_region *)region_void;
Node_tool_set_Cmiss_region(node_tool, region);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_update_region. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_update_region */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_update_coordinate_field(Widget widget,
void *node_tool_void,void *coordinate_field_void)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Callback for change of coordinate_field.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_update_coordinate_field);
USE_PARAMETER(widget);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_coordinate_field(node_tool,
(struct Computed_field *)coordinate_field_void);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_update_coordinate_field. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_update_coordinate_field */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_destroy_selected_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 28 April 2003
DESCRIPTION :
Attempts to destroy all the nodes currently in the global selection.
==============================================================================*/
{
struct LIST(FE_node) *destroy_node_list;
struct Node_tool *node_tool;
struct FE_region *master_fe_region;
ENTER(Node_tool_destroy_selected_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (destroy_node_list=CREATE(LIST(FE_node))())
{
COPY_LIST(FE_node)(destroy_node_list,
FE_node_selection_get_node_list(node_tool->node_selection));
/* nodes destroyed only if removed from ultimate master FE_region */
if (FE_region_get_ultimate_master_FE_region(node_tool->fe_region,
&master_fe_region))
{
FE_region_begin_change(master_fe_region);
FE_region_remove_FE_node_list(master_fe_region, destroy_node_list);
FE_region_end_change(master_fe_region);
}
DESTROY(LIST(FE_node))(&destroy_node_list);
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_destroy_selected_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_destroy_selected_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_undefine_selected_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 29 April 2003
DESCRIPTION :
Attempts to undefine all the nodes currently in the global selection.
==============================================================================*/
{
int number_in_elements;
struct FE_field *fe_field;
struct LIST(FE_field) *fe_field_list;
struct LIST(FE_node) *node_list;
struct Node_tool *node_tool;
ENTER(Node_tool_undefine_selected_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list))&&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)))
{
node_list = CREATE(LIST(FE_node))();
if (COPY_LIST(FE_node)(node_list,
FE_node_selection_get_node_list(node_tool->node_selection)))
{
FE_region_begin_change(node_tool->fe_region);
FE_region_undefine_FE_field_in_FE_node_list(
node_tool->fe_region, fe_field, node_list, &number_in_elements);
display_message(WARNING_MESSAGE,
"Field could not be undefined in %d node(s) "
"because in-use by elements", number_in_elements);
FE_region_end_change(node_tool->fe_region);
}
DESTROY(LIST(FE_node))(&node_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. Invalid field");
}
DESTROY(LIST(FE_field))(&fe_field_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. No field to undefine");
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_undefine_selected_CB */
#endif /* defined (MOTIF) */
static void Node_tool_reset(void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 25 February 2008
DESCRIPTION :
Resets current edit. Called on button release or when tool deactivated.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_reset);
if (node_tool = (struct Node_tool *)node_tool_void)
{
REACCESS(FE_node)(&(node_tool->last_picked_node),
(struct FE_node *)NULL);
REACCESS(Interaction_volume)(
&(node_tool->last_interaction_volume),
(struct Interaction_volume *)NULL);
REACCESS(Scene_picked_object)(&(node_tool->scene_picked_object),
(struct Scene_picked_object *)NULL);
REACCESS(GT_element_group)(&(node_tool->gt_element_group),
(struct GT_element_group *)NULL);
REACCESS(GT_element_settings)(&(node_tool->gt_element_settings),
(struct GT_element_settings *)NULL);
}
else
{
display_message(ERROR_MESSAGE,"Node_tool_reset. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_reset */
static void Node_tool_interactive_event_handler(void *device_id,
struct Interactive_event *event,void *node_tool_void,
struct Graphics_buffer *graphics_buffer)
/*******************************************************************************
LAST MODIFIED : 13 February 2008
DESCRIPTION :
Input handler for input from devices. <device_id> is a unique address enabling
the editor to handle input from more than one device at a time. The <event>
describes the type of event, button numbers and key modifiers, and the volume
of space affected by the interaction. Main events are button press, movement and
release.
==============================================================================*/
{
char *command_string;
double d;
enum Glyph_scaling_mode glyph_scaling_mode;
enum Interactive_event_type event_type;
FE_value time;
int clear_selection,input_modifier,return_code,shift_pressed;
struct Computed_field *coordinate_field, *nearest_element_coordinate_field;
struct FE_element *nearest_element;
struct FE_node *picked_node;
struct FE_node_edit_information edit_info;
struct GT_element_group *gt_element_group, *gt_element_group_element;
struct GT_element_settings *gt_element_settings, *gt_element_settings_element;
struct GT_object *glyph;
struct Interaction_volume *interaction_volume,*temp_interaction_volume;
struct LIST(FE_node) *node_list;
struct LIST(Scene_picked_object) *scene_picked_object_list;
struct Node_tool *node_tool;
struct Scene *scene;
struct Scene_picked_object *scene_picked_object, *scene_picked_object2;
ENTER(Node_tool_interactive_event_handler);
if (device_id&&event&&(node_tool=
(struct Node_tool *)node_tool_void))
{
interaction_volume=Interactive_event_get_interaction_volume(event);
if (scene=Interactive_event_get_scene(event))
{
event_type=Interactive_event_get_type(event);
input_modifier=Interactive_event_get_input_modifier(event);
shift_pressed=(INTERACTIVE_EVENT_MODIFIER_SHIFT & input_modifier);
switch (event_type)
{
case INTERACTIVE_EVENT_BUTTON_PRESS:
{
/* interaction only works with first mouse button */
if (1==Interactive_event_get_button_number(event))
{
REACCESS(Interaction_volume)(&(node_tool->last_interaction_volume),
interaction_volume);
if (scene_picked_object_list=
Scene_pick_objects(scene,interaction_volume,graphics_buffer))
{
picked_node=(struct FE_node *)NULL;
nearest_element = (struct FE_element *)NULL;
if (node_tool->select_enabled)
{
picked_node=Scene_picked_object_list_get_nearest_node(
scene_picked_object_list,node_tool->use_data,
(struct Cmiss_region *)NULL,&scene_picked_object,
>_element_group,>_element_settings);
}
if (node_tool->constrain_to_surface)
{
nearest_element=Scene_picked_object_list_get_nearest_element(
scene_picked_object_list,(struct Cmiss_region *)NULL,
/*select_elements_enabled*/0, /*select_faces_enabled*/1,
/*select_lines_enabled*/0, &scene_picked_object2,
>_element_group_element,>_element_settings_element);
/* Reject the previously picked node if the element is nearer */
if (picked_node && nearest_element)
{
if (Scene_picked_object_get_nearest(scene_picked_object) >
Scene_picked_object_get_nearest(scene_picked_object2))
{
picked_node = (struct FE_node *)NULL;
}
}
}
if (picked_node)
{
node_tool->picked_node_was_unselected=
!FE_node_selection_is_node_selected(node_tool->node_selection,
picked_node);
REACCESS(Scene_picked_object)(
&(node_tool->scene_picked_object),scene_picked_object);
REACCESS(GT_element_group)(&(node_tool->gt_element_group),
gt_element_group);
REACCESS(GT_element_settings)(
&(node_tool->gt_element_settings),gt_element_settings);
if (node_tool->define_enabled)
{
if (!Computed_field_is_defined_at_node(
node_tool->coordinate_field,picked_node))
{
Node_tool_define_field_at_node_from_picked_coordinates(
node_tool,picked_node);
}
}
}
else
{
if (node_tool->create_enabled)
{
/* Find the intersection of the element and the interaction volume */
nearest_element_coordinate_field = (struct Computed_field *)NULL;
if (nearest_element)
{
if (!(nearest_element_coordinate_field =
GT_element_settings_get_coordinate_field(gt_element_settings_element)))
{
nearest_element_coordinate_field =
GT_element_group_get_default_coordinate_field(
gt_element_group_element);
}
}
/* If we are creating on elements and no element was selected then
don't create */
if (!node_tool->constrain_to_surface || nearest_element)
{
if (picked_node=Node_tool_create_node_at_interaction_volume(
node_tool,scene,interaction_volume,nearest_element,
nearest_element_coordinate_field))
{
node_tool->picked_node_was_unselected=1;
}
else
{
node_tool->picked_node_was_unselected=0;
}
}
else
{
node_tool->picked_node_was_unselected=0;
}
}
else
{
node_tool->picked_node_was_unselected=0;
}
}
REACCESS(FE_node)(&(node_tool->last_picked_node),picked_node);
DESTROY(LIST(Scene_picked_object))(&(scene_picked_object_list));
/*
* NOTE: make selection the last step so node_tool is in good state before
* receiving code gets to run: consider it capable of changing the current tool!
*/
if (clear_selection = !shift_pressed)
#if defined (OLD_CODE)
&&((!picked_node)||(node_tool->picked_node_was_unselected))))
#endif /*defined (OLD_CODE) */
{
FE_node_selection_begin_cache(node_tool->node_selection);
FE_node_selection_clear(node_tool->node_selection);
}
if (picked_node)
{
FE_node_selection_select_node(node_tool->node_selection,
picked_node);
}
if (clear_selection)
{
FE_node_selection_end_cache(node_tool->node_selection);
}
}
}
node_tool->motion_detected=0;
} break;
case INTERACTIVE_EVENT_MOTION_NOTIFY:
case INTERACTIVE_EVENT_BUTTON_RELEASE:
{
if (node_tool->last_interaction_volume&&
((INTERACTIVE_EVENT_MOTION_NOTIFY==event_type) ||
(1==Interactive_event_get_button_number(event))))
{
nearest_element = (struct FE_element *)NULL;
nearest_element_coordinate_field = (struct Computed_field *)NULL;
if (INTERACTIVE_EVENT_MOTION_NOTIFY==event_type)
{
node_tool->motion_detected=1;
}
if (node_tool->last_picked_node)
{
if (node_tool->constrain_to_surface)
{
if (scene_picked_object_list=
Scene_pick_objects(scene,interaction_volume,graphics_buffer))
{
if (nearest_element=Scene_picked_object_list_get_nearest_element(
scene_picked_object_list,(struct Cmiss_region *)NULL,
/*select_elements_enabled*/0, /*select_faces_enabled*/1,
/*select_lines_enabled*/0, &scene_picked_object2,
>_element_group_element,>_element_settings_element))
{
if (!(nearest_element_coordinate_field =
GT_element_settings_get_coordinate_field(gt_element_settings_element)))
{
nearest_element_coordinate_field =
GT_element_group_get_default_coordinate_field(
gt_element_group_element);
}
}
DESTROY(LIST(Scene_picked_object))(&(scene_picked_object_list));
}
}
if (node_tool->create_enabled &&
node_tool->streaming_create_enabled &&
(INTERACTIVE_EVENT_MOTION_NOTIFY == event_type))
{
if (!node_tool->constrain_to_surface || nearest_element)
{
if (picked_node = Node_tool_create_node_at_interaction_volume(
node_tool, scene, interaction_volume, nearest_element,
nearest_element_coordinate_field))
{
FE_node_selection_select_node(node_tool->node_selection,
picked_node);
REACCESS(FE_node)(&(node_tool->last_picked_node),
picked_node);
}
}
}
else if ((node_tool->edit_enabled)&&node_tool->motion_detected &&
(((INTERACTIVE_EVENT_MOTION_NOTIFY==event_type)&&
node_tool->motion_update_enabled)||
((INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)&&
(!node_tool->motion_update_enabled))))
{
return_code=1;
/* establish edit_info */
edit_info.last_picked_node = (struct FE_node *)NULL;
edit_info.delta1=0.0;
edit_info.delta2=0.0;
edit_info.delta3=0.0;
edit_info.initial_interaction_volume=
node_tool->last_interaction_volume;
edit_info.final_interaction_volume=interaction_volume;
edit_info.fe_region=node_tool->fe_region;
edit_info.time=Time_keeper_get_time(
node_tool->time_keeper);
edit_info.constrain_to_surface = node_tool->constrain_to_surface;
edit_info.element_xi_field = node_tool->element_xi_field;
edit_info.nearest_element = nearest_element;
edit_info.nearest_element_coordinate_field =
nearest_element_coordinate_field;
/* get coordinate field to edit */
if (node_tool->define_enabled)
{
coordinate_field=node_tool->coordinate_field;
}
else if (!(coordinate_field=
GT_element_settings_get_coordinate_field(
node_tool->gt_element_settings)))
{
coordinate_field=
GT_element_group_get_default_coordinate_field(
node_tool->gt_element_group);
}
edit_info.coordinate_field=coordinate_field;
/* get coordinate_field in RC coordinates */
edit_info.rc_coordinate_field=
Computed_field_begin_wrap_coordinate_field(coordinate_field);
edit_info.orientation_scale_field=(struct Computed_field *)NULL;
edit_info.wrapper_orientation_scale_field=
(struct Computed_field *)NULL;
if (!node_tool->gt_element_settings)
{
edit_info.glyph_centre[0] = 0.0;
edit_info.glyph_centre[1] = 0.0;
edit_info.glyph_centre[2] = 0.0;
edit_info.glyph_size[0] = 1.0;
edit_info.glyph_size[1] = 1.0;
edit_info.glyph_size[2] = 1.0;
}
else if (GT_element_settings_get_glyph_parameters(
node_tool->gt_element_settings, &glyph, &glyph_scaling_mode,
edit_info.glyph_centre,edit_info.glyph_size,
&(edit_info.orientation_scale_field),
edit_info.glyph_scale_factors,
&(edit_info.variable_scale_field)))
{
if (edit_info.orientation_scale_field)
{
edit_info.wrapper_orientation_scale_field=
Computed_field_begin_wrap_orientation_scale_field(
edit_info.orientation_scale_field,
edit_info.rc_coordinate_field);
}
}
else
{
return_code=0;
}
/* work out scene_object transformation information */
if (!node_tool->scene_picked_object)
{
/* best we can do is use world coordinates;
* will look wrong if nodes drawn with a transformation */
edit_info.transformation_required=0;
}
else if (!(Scene_picked_object_get_total_transformation_matrix(
node_tool->scene_picked_object,
&(edit_info.transformation_required),
edit_info.transformation_matrix)&&
copy_matrix(4,4,edit_info.transformation_matrix,
edit_info.LU_transformation_matrix)&&
((!edit_info.transformation_required)||
LU_decompose(4,edit_info.LU_transformation_matrix,
edit_info.LU_indx,&d,/*singular_tolerance*/1.0e-12))))
{
return_code=0;
}
if (return_code)
{
if (node_list=FE_node_selection_get_node_list(
node_tool->node_selection))
{
FE_region_begin_change(node_tool->fe_region);
/* edit vectors if non-constant orientation_scale field */
if (((NODE_TOOL_EDIT_AUTOMATIC == node_tool->edit_mode) ||
(NODE_TOOL_EDIT_VECTOR == node_tool->edit_mode))&&
edit_info.wrapper_orientation_scale_field&&
(!Computed_field_is_constant(
edit_info.orientation_scale_field)))
{
/* edit vector */
if (FE_node_calculate_delta_vector(
node_tool->last_picked_node,(void *)&edit_info))
{
FOR_EACH_OBJECT_IN_LIST(FE_node)(FE_node_edit_vector,
(void *)&edit_info,node_list);
}
}
else
{
if (NODE_TOOL_EDIT_VECTOR != node_tool->edit_mode)
{
/* edit position */
if (FE_node_calculate_delta_position(
node_tool->last_picked_node,(void *)&edit_info))
{
FOR_EACH_OBJECT_IN_LIST(FE_node)(
FE_node_edit_position,(void *)&edit_info,node_list);
}
}
else
{
display_message(ERROR_MESSAGE,"Cannot edit vector: "
"invalid orientation_scale field");
return_code=0;
}
}
FE_region_end_change(node_tool->fe_region);
}
else
{
return_code=0;
}
}
if (edit_info.orientation_scale_field)
{
Computed_field_end_wrap(
&(edit_info.wrapper_orientation_scale_field));
}
Computed_field_end_wrap(&(edit_info.rc_coordinate_field));
}
else
{
/* unselect last_picked_node if not just added */
if ((INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)&&
shift_pressed&&(!(node_tool->picked_node_was_unselected))&&
(!(node_tool->edit_enabled && node_tool->motion_detected)))
{
FE_node_selection_unselect_node(node_tool->node_selection,
node_tool->last_picked_node);
}
}
}
else if (node_tool->motion_detected)
{
/* rubber band select - make bounding box out of initial and
current interaction_volumes */
if (temp_interaction_volume=
create_Interaction_volume_bounding_box(
node_tool->last_interaction_volume,interaction_volume))
{
if (INTERACTIVE_EVENT_MOTION_NOTIFY==event_type)
{
if (!node_tool->rubber_band)
{
/* create rubber_band object and put in scene */
node_tool->rubber_band=CREATE(GT_object)(
"node_tool_rubber_band",g_POLYLINE,
node_tool->rubber_band_material);
ACCESS(GT_object)(node_tool->rubber_band);
Scene_add_graphics_object(scene,node_tool->rubber_band,
/*position*/0,"node_tool_rubber_band",
/*fast_changing*/1);
}
Interaction_volume_make_polyline_extents(
temp_interaction_volume,node_tool->rubber_band);
}
else
{
Scene_remove_graphics_object(scene,node_tool->rubber_band);
DEACCESS(GT_object)(&(node_tool->rubber_band));
}
if (INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)
{
if (scene_picked_object_list=
Scene_pick_objects(scene,temp_interaction_volume,graphics_buffer))
{
if (node_list=Scene_picked_object_list_get_picked_nodes(
scene_picked_object_list,node_tool->use_data))
{
FE_node_selection_begin_cache(node_tool->node_selection);
FOR_EACH_OBJECT_IN_LIST(FE_node)(
FE_node_select_in_FE_node_selection,
(void *)(node_tool->node_selection),node_list);
FE_node_selection_end_cache(node_tool->node_selection);
DESTROY(LIST(FE_node))(&node_list);
}
DESTROY(LIST(Scene_picked_object))(
&(scene_picked_object_list));
}
}
DESTROY(Interaction_volume)(&temp_interaction_volume);
}
}
if (INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)
{
/* Execute command_field of last_picked_node as last step of button release as code
* invoked by it may modify this tool, or change to another tool before returning */
if (node_tool->last_picked_node && node_tool->command_field &&
Computed_field_is_defined_at_node(node_tool->command_field,
node_tool->last_picked_node))
{
if (node_tool->time_keeper)
{
time = Time_keeper_get_time(node_tool->time_keeper);
}
else
{
time = 0;
}
if (command_string = Computed_field_evaluate_as_string_at_node(
node_tool->command_field, /*component_number*/-1,
node_tool->last_picked_node, time))
{
Execute_command_execute_string(node_tool->execute_command,
command_string);
DEALLOCATE(command_string);
}
}
Node_tool_reset((void *)node_tool);
}
else if (node_tool->last_picked_node&&
node_tool->motion_update_enabled)
{
REACCESS(Interaction_volume)(
&(node_tool->last_interaction_volume),interaction_volume);
}
}
} break;
default:
{
display_message(ERROR_MESSAGE,
"Node_tool_interactive_event_handler. "
"Unknown event type");
} break;
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_interactive_event_handler. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_interactive_event_handler */
#if defined (WX_USER_INTERFACE)
static int Node_tool_destroy_node_tool(void **node_tool_void)
/*******************************************************************************
LAST MODIFIED : 6 July 2007
DESCRIPTION :
Function to call DESTROY
==============================================================================*/
{
ENTER(Node_tool_destroy_node_tool);
Node_tool *node_tool;
int return_code;
return_code=0;
if (node_tool = (struct Node_tool *)*node_tool_void)
{
return_code = DESTROY(Node_tool)(&node_tool);
}
LEAVE;
return (return_code);
}
#endif /*defined (WX_USER_INTERFACE)*/
static int Node_tool_bring_up_interactive_tool_dialog(void *node_tool_void,
struct Graphics_window *graphics_window)
/*******************************************************************************
LAST MODIFIED : 20 June 2001
DESCRIPTION :
Brings up a dialog for editing settings of the Node_tool - in a standard format
for passing to an Interactive_toolbar.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_bring_up_interactive_tool_dialog);
return_code = Node_tool_pop_up_dialog((struct Node_tool *)node_tool_void,
graphics_window);
LEAVE;
return (return_code);
} /* Node_tool_bring_up_interactive_tool_dialog */
static struct Cmgui_image *Node_tool_get_icon(struct Colour *foreground,
struct Colour *background, void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 5 July 2002
DESCRIPTION :
Fetches the appropriate icon for the interactive tool.
==============================================================================*/
{
#if defined (MOTIF)
char *icon_name;
Display *display;
Pixel background_pixel, foreground_pixel;
Pixmap pixmap;
#endif /* defined (MOTIF) */
struct Cmgui_image *image;
struct Node_tool *node_tool;
ENTER(node_tool_get_icon);
if ((node_tool=(struct Node_tool *)node_tool_void))
{
#if defined (MOTIF)
if (MrmOpenHierarchy_binary_string(node_tool_uidh,sizeof(node_tool_uidh),
&node_tool_hierarchy,&node_tool_hierarchy_open))
{
if (node_tool->use_data)
{
icon_name="data_tool_icon";
}
else
{
icon_name="node_tool_icon";
}
display = node_tool->display;
convert_Colour_to_Pixel(display, foreground, &foreground_pixel);
convert_Colour_to_Pixel(display, background, &background_pixel);
if (MrmSUCCESS == MrmFetchIconLiteral(node_tool_hierarchy,
icon_name,DefaultScreenOfDisplay(display),display,
foreground_pixel, background_pixel, &pixmap))
{
image = create_Cmgui_image_from_Pixmap(display, pixmap);
}
else
{
display_message(WARNING_MESSAGE, "Node_tool_get_icon. "
"Could not fetch widget");
image = (struct Cmgui_image *)NULL;
}
}
else
{
display_message(WARNING_MESSAGE, "Node_tool_get_icon. "
"Could not open heirarchy");
image = (struct Cmgui_image *)NULL;
}
#else /* defined (MOTIF) */
USE_PARAMETER(foreground);
USE_PARAMETER(background);
USE_PARAMETER(node_tool);
display_message(WARNING_MESSAGE, "Node_tool_get_icon. "
"Not implemented for this user interface.");
#endif /* defined (MOTIF) */
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_icon. Invalid argument(s)");
image = (struct Cmgui_image *)NULL;
}
LEAVE;
return (image);
} /* Node_tool_get_icon */
#if defined (WX_USER_INTERFACE)
class wxNodeTool : public wxPanel
{
Node_tool *node_tool;
FE_region *master_fe_region;
FE_field *fe_field;
wxCheckBox *button_select;
wxCheckBox *button_edit;
wxCheckBox *button_motion_update;
wxCheckBox *button_define;
wxCheckBox *button_create;
wxCheckBox *button_streaming;
wxCheckBox *button_constrain;
wxButton *button_destroy;
wxButton *button_undefine;
wxWindow *Title;
wxRegionChooser *region_chooser;
wxCheckBox *node_command_field_checkbox;
wxPanel *node_command_field_chooser_panel;
wxCheckBox *element_xi_field_checkbox;
wxPanel *element_xi_field_chooser_panel;
wxPanel *cmgui_node_tool;
wxButton *clear_button;
wxCheckBox *create_elements_checkbox;
wxTextCtrl *dimension_textctrl;
wxListBox *new_element_nodes_listbox;
wxStaticText *new_element_statictext, *dimension_statictext;
wxWindow *first_element_staticbox,*second_element_staticbox;
char temp_string[20];
DEFINE_MANAGER_CLASS(Computed_field);
Managed_object_chooser<Computed_field, MANAGER_CLASS(Computed_field)>
*computed_field_chooser;
Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
*node_command_field_chooser;
Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
*element_xi_field_chooser;
public:
wxNodeTool(Node_tool *node_tool, wxPanel *parent):
node_tool(node_tool)
{
struct Computed_field *command_field, *element_xi_field;
{ // Suppress the error message if we have already initialised this xrc
wxLogNull logNo;
wxXmlInit_node_tool();
} // ~wxLogNull called, old log restored
wxXmlResource::Get()->LoadPanel(this, parent, _T("CmguiNodeTool"));
button_select = XRCCTRL(*this, "ButtonSelect", wxCheckBox);
button_edit = XRCCTRL(*this, "ButtonEdit", wxCheckBox);
button_motion_update=XRCCTRL(*this, "ButtonMotionUpdate", wxCheckBox);
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
button_streaming = XRCCTRL(*this, "ButtonStreaming", wxCheckBox);
button_constrain = XRCCTRL(*this, "ButtonConstrain", wxCheckBox );
button_select->SetValue(node_tool->select_enabled);
button_edit->SetValue(node_tool->edit_enabled);
button_motion_update->SetValue(node_tool->motion_update_enabled);
button_define->SetValue(node_tool->define_enabled);
button_create->SetValue(node_tool->create_enabled);
button_streaming->SetValue(node_tool->streaming_create_enabled);
button_constrain ->SetValue(node_tool->constrain_to_surface);
create_elements_checkbox = XRCCTRL(*this, "CreateElementsCheckBox", wxCheckBox );
dimension_textctrl = XRCCTRL(*this, "DimensionTextCtrl", wxTextCtrl);
clear_button = XRCCTRL(*this, "ClearButton", wxButton);
new_element_nodes_listbox = XRCCTRL(*this, "NewElementNodesListBox", wxListBox);
new_element_statictext = XRCCTRL(*this, "NewElementStaticText",wxStaticText);
dimension_statictext = XRCCTRL(*this, "DimensionStaticText",wxStaticText);
first_element_staticbox = XRCCTRL(*this, "FirstElementStaticBox",wxWindow);
second_element_staticbox = XRCCTRL(*this, "SecondElementStaticBox",wxWindow);
Title = XRCCTRL(*this,"NodeSizer",wxWindow);
if (node_tool->use_data)
{
Title->SetLabel("Data Tool");
create_elements_checkbox->Hide();
dimension_textctrl->Hide();
clear_button->Hide();
new_element_nodes_listbox->Hide();
new_element_statictext->Hide();
dimension_statictext->Hide();
first_element_staticbox->Hide();
second_element_staticbox->Hide();
}
else
{
Title->SetLabel("Node Tool");
create_elements_checkbox->Show();
dimension_textctrl->Show();
clear_button->Show();
new_element_nodes_listbox->Show();
new_element_statictext->Show();
dimension_statictext->Show();
create_elements_checkbox->SetValue(node_tool->element_create_enabled);
sprintf(temp_string,"%d",node_tool->element_dimension);
dimension_textctrl->SetValue(temp_string);
first_element_staticbox->Show();
second_element_staticbox->Show();
}
wxPanel *coordinate_field_chooser_panel =
XRCCTRL(*this, "CoordinateFieldChooserPanel", wxPanel);
computed_field_chooser =
new Managed_object_chooser<Computed_field, MANAGER_CLASS(Computed_field)>
(coordinate_field_chooser_panel, node_tool->coordinate_field,
node_tool->computed_field_manager,
Computed_field_has_up_to_3_numerical_components,
(void *)NULL, node_tool->user_interface);
Callback_base<Computed_field* > *coordinate_field_callback =
new Callback_member_callback< Computed_field*,
wxNodeTool, int (wxNodeTool::*)(Computed_field *) >
(this, &wxNodeTool::coordinate_field_callback);
computed_field_chooser->set_callback(coordinate_field_callback);
wxPanel *region_chooser_panel =
XRCCTRL(*this, "RegionChooserPanel", wxPanel);
char *initial_path;
Cmiss_region_get_root_region_path(&initial_path);
region_chooser = new wxRegionChooser(region_chooser_panel,
node_tool->root_region, initial_path);
DEALLOCATE(initial_path);
Callback_base<Cmiss_region* > *region_callback =
new Callback_member_callback< Cmiss_region*,
wxNodeTool, int (wxNodeTool::*)(Cmiss_region *) >
(this, &wxNodeTool::region_callback);
region_chooser->set_callback(region_callback);
if (node_tool->current_region_path != NULL)
{
wx_Node_tool_set_region_path(node_tool->current_region_path);
}
node_command_field_checkbox = XRCCTRL(*this, "NodeCommandFieldCheckBox",wxCheckBox);
node_command_field_chooser_panel = XRCCTRL(*this, "NodeCommandFieldChooserPanel", wxPanel);
command_field = Node_tool_get_command_field(node_tool);
node_command_field_chooser =
new Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
(node_command_field_chooser_panel, command_field, node_tool->computed_field_manager,
Computed_field_has_string_value_type, (void *)NULL, node_tool->user_interface);
Callback_base< Computed_field* > *node_command_field_callback =
new Callback_member_callback< Computed_field*,
wxNodeTool, int (wxNodeTool::*)(Computed_field *) >
(this, &wxNodeTool::node_command_field_callback);
node_command_field_chooser->set_callback(node_command_field_callback);
if (command_field == NULL)
{
node_command_field_checkbox->SetValue(0);
node_command_field_chooser_panel->Disable();
}
else
{
node_command_field_checkbox->SetValue(1);
node_command_field_chooser_panel->Enable();
}
element_xi_field_checkbox = XRCCTRL(*this, "ElementXiFieldCheckBox",wxCheckBox);
element_xi_field_chooser_panel = XRCCTRL(*this, "ElementXiFieldChooserPanel", wxPanel);
element_xi_field = Node_tool_get_element_xi_field(node_tool);
element_xi_field_chooser =
new Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
(element_xi_field_chooser_panel, element_xi_field, node_tool->computed_field_manager,
Computed_field_has_element_xi_fe_field, (void *)NULL, node_tool->user_interface);
Callback_base< Computed_field* > *element_xi_field_callback =
new Callback_member_callback< Computed_field*,
wxNodeTool, int (wxNodeTool::*)(Computed_field *) >
(this, &wxNodeTool::element_xi_field_callback);
element_xi_field_chooser->set_callback(element_xi_field_callback);
if (element_xi_field == NULL)
{
element_xi_field_checkbox->SetValue(0);
element_xi_field_chooser_panel->Disable();
}
else
{
element_xi_field_checkbox->SetValue(1);
element_xi_field_chooser_panel->Enable();
}
cmgui_node_tool = XRCCTRL(*this, "CmguiNodeTool", wxPanel);
cmgui_node_tool->SetScrollbar(wxVERTICAL,0,-1,-1);
cmgui_node_tool -> Layout();
}
wxNodeTool() /* Void constructor required for IMPLEMENT_DYNAMIC_CLASS */
{
}
~wxNodeTool()
{
if (computed_field_chooser)
delete computed_field_chooser;
if (region_chooser)
delete region_chooser;
if (node_command_field_chooser)
delete node_command_field_chooser;
if (element_xi_field_chooser)
delete element_xi_field_chooser;
}
int coordinate_field_callback(Computed_field *field)
/*******************************************************************************
LAST MODIFIED : 9 February 2007
DESCRIPTION :
Callback from wxChooser<Computed_field> when choice is made.
==============================================================================*/
{
Node_tool_set_coordinate_field(node_tool, field);
return 1;
}
int region_callback(Cmiss_region *region)
/*******************************************************************************
LAST MODIFIED : 9 February 2007
DESCRIPTION :
Callback from wxChooser<Computed_field> when choice is made.
==============================================================================*/
{
Node_tool_set_Cmiss_region(node_tool, region);
return 1;
}
int setCoordinateField(Computed_field *field)
/*******************************************************************************
LAST MODIFIED : 9 February 2007
DESCRIPTION :
Set the selected option in the Coordinate Field chooser.
==============================================================================*/
{
computed_field_chooser->set_object(field);
return 1;
}
int node_command_field_callback(Computed_field *command_field)
{
Node_tool_set_command_field(node_tool, command_field);
return 1;
}
int element_xi_field_callback(Computed_field *element_xi_field)
{
Node_tool_set_element_xi_field(node_tool, element_xi_field);
return 1;
}
void OnButtonSelectpressed(wxCommandEvent& event)
{
button_select = XRCCTRL(*this, "ButtonSelect", wxCheckBox);
Node_tool_set_select_enabled(node_tool,button_select->IsChecked());
}
void OnButtonEditpressed(wxCommandEvent& event)
{
button_edit = XRCCTRL(*this, "ButtonEdit", wxCheckBox);
Node_tool_set_edit_enabled(node_tool,button_edit->IsChecked());
}
void OnButtonMotionUpdatepressed(wxCommandEvent& event)
{
button_motion_update = XRCCTRL(*this, "ButtonMotionUpdate", wxCheckBox);
Node_tool_set_motion_update_enabled(node_tool,button_motion_update->IsChecked());
}
void OnButtonDefinepressed(wxCommandEvent& event)
{
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
Node_tool_set_define_enabled(node_tool,button_define->IsChecked());
if (!button_define->IsChecked())
{
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
button_create->SetValue(0);
Node_tool_set_create_enabled(node_tool,button_create->IsChecked());
}
}
void OnButtonCreatepressed(wxCommandEvent& event)
{
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
Node_tool_set_create_enabled(node_tool,button_create->IsChecked());
if (button_create->IsChecked())
{
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
button_define->SetValue(1);
Node_tool_set_define_enabled(node_tool,button_define->IsChecked());
}
}
void OnButtonStreamingpressed(wxCommandEvent& event)
{
button_streaming = XRCCTRL(*this, "ButtonStreaming", wxCheckBox);
Node_tool_set_streaming_create_enabled(node_tool,button_streaming->IsChecked());
}
void OnButtonConstrainpressed(wxCommandEvent& event)
{
button_constrain = XRCCTRL(*this, "ButtonConstrain", wxCheckBox );
Node_tool_set_constrain_to_surface(node_tool,button_constrain->IsChecked());
}
void OnButtonDestroypressed(wxCommandEvent& event)
{
struct LIST(FE_node) *destroy_node_list;
button_destroy = XRCCTRL(*this, "ButtonDestroy", wxButton);;
if (destroy_node_list=CREATE(LIST(FE_node))())
{
COPY_LIST(FE_node)(destroy_node_list,
FE_node_selection_get_node_list(node_tool->node_selection));
/* nodes destroyed only if removed from ultimate master FE_region */
if (FE_region_get_ultimate_master_FE_region(node_tool->fe_region,
&master_fe_region))
{
FE_region_begin_change(master_fe_region);
FE_region_remove_FE_node_list(master_fe_region, destroy_node_list);
FE_region_end_change(master_fe_region);
}
DESTROY(LIST(FE_node))(&destroy_node_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_destroy_selected_CB. Invalid argument(s)");
}
LEAVE;
}
void OnButtonUndefinepressed(wxCommandEvent& event)
{
int number_in_elements;
struct LIST(FE_field) *fe_field_list;
struct LIST(FE_node) *node_list;
button_undefine = XRCCTRL(*this, "ButtonUndefine", wxButton);
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list))&&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)))
{
node_list = CREATE(LIST(FE_node))();
if (COPY_LIST(FE_node)(node_list,
FE_node_selection_get_node_list(node_tool->node_selection)))
{
FE_region_begin_change(node_tool->fe_region);
FE_region_undefine_FE_field_in_FE_node_list(
node_tool->fe_region, fe_field, node_list, &number_in_elements);
display_message(WARNING_MESSAGE,
"Field could not be undefined in %d node(s) "
"because in-use by elements", number_in_elements);
FE_region_end_change(node_tool->fe_region);
}
DESTROY(LIST(FE_node))(&node_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. Invalid field");
}
DESTROY(LIST(FE_field))(&fe_field_list);
}
}
void OnClearButtonpressed(wxCommandEvent &event)
{
if (node_tool)
{
Node_tool_end_element_creation(node_tool);
}
else
{
display_message(ERROR_MESSAGE,
"Element_creator_abort_creation_CB. Invalid argument(s)");
}
}
void OnCreateElementsPressed(wxCommandEvent &event)
{
create_elements_checkbox = XRCCTRL(*this, "CreateElementsCheckBox", wxCheckBox );
if (node_tool)
{
Node_tool_set_element_create_enabled(node_tool,
create_elements_checkbox->IsChecked());
}
else
{
display_message(ERROR_MESSAGE,
"Element_creator_create_button_CB. Invalid argument(s)");
}
}
void OnDimensionEntered(wxCommandEvent &event)
{
char *value_string;
int element_dimension;
dimension_textctrl = XRCCTRL(*this, "DimensionTextCtrl", wxTextCtrl);
if (node_tool)
{
if (value_string=const_cast<char *>((dimension_textctrl->GetValue()).c_str()))
{
if (1==sscanf(value_string,"%d",&element_dimension))
{
Node_tool_set_element_dimension(node_tool,
element_dimension);
}
}
/* always restore element_dimension_text to actual value stored */
Node_tool_refresh_element_dimension_text(node_tool);
}
else
{
display_message(ERROR_MESSAGE,
"Element_creator_element_dimension_text_CB. Invalid argument(s)");
}
}
void NodeToolInterfaceRenew_element_xi_field(Node_tool *node_tool)
{
struct Computed_field *element_xi_field = Node_tool_get_element_xi_field(node_tool);
element_xi_field_checkbox->SetValue(element_xi_field != 0);
if (element_xi_field)
{
element_xi_field_chooser->set_object(element_xi_field);
element_xi_field_chooser_panel->Enable();
}
else
{
element_xi_field_chooser_panel->Disable();
}
}
void NodeToolInterfaceRenew(Node_tool *destination_node_tool)
{
button_select = XRCCTRL(*this, "ButtonSelect", wxCheckBox);
button_edit = XRCCTRL(*this, "ButtonEdit", wxCheckBox);
button_motion_update=XRCCTRL(*this, "ButtonMotionUpdate", wxCheckBox);
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
button_streaming = XRCCTRL(*this, "ButtonStreaming", wxCheckBox);
button_constrain = XRCCTRL(*this, "ButtonConstrain", wxCheckBox );
create_elements_checkbox = XRCCTRL(*this, "CreateElementsCheckBox", wxCheckBox );
dimension_textctrl = XRCCTRL(*this, "DimensionTextCtrl", wxTextCtrl);
button_select->SetValue(destination_node_tool->select_enabled);
button_edit->SetValue(destination_node_tool->edit_enabled);
button_motion_update->SetValue(destination_node_tool->motion_update_enabled);
button_define->SetValue(destination_node_tool->define_enabled);
button_create->SetValue(destination_node_tool->create_enabled);
button_streaming->SetValue(destination_node_tool->streaming_create_enabled);
button_constrain->SetValue(destination_node_tool->constrain_to_surface);
NodeToolInterfaceRenew_element_xi_field(destination_node_tool);
computed_field_chooser->set_object(destination_node_tool->coordinate_field);
if (destination_node_tool->current_region_path != NULL)
{
wx_Node_tool_set_region_path(destination_node_tool->current_region_path);
}
Node_tool_set_element_dimension(destination_node_tool,destination_node_tool->element_dimension);
create_elements_checkbox->SetValue(destination_node_tool->element_create_enabled);
}
void NodeCommandFieldChecked(wxCommandEvent &event)
{
struct Computed_field *command_field = (struct Computed_field *)NULL;
if (node_command_field_checkbox->IsChecked() &&
(command_field = node_command_field_chooser->get_object()))
{
node_command_field_chooser_panel->Enable();
}
else
{
node_command_field_checkbox->SetValue(0);
node_command_field_chooser_panel->Disable();
}
Node_tool_set_command_field(node_tool, command_field);
}
void ElementXiFieldChecked(wxCommandEvent &event)
{
struct Computed_field *element_xi_field = (struct Computed_field *)NULL;
if (element_xi_field_checkbox->IsChecked() &&
(element_xi_field = element_xi_field_chooser->get_object()))
{
element_xi_field_chooser_panel->Enable();
}
else
{
element_xi_field_checkbox->SetValue(0);
element_xi_field_chooser_panel->Disable();
}
Node_tool_set_element_xi_field(node_tool, element_xi_field);
}
int wx_Node_tool_get_region_path(char **path_address)
{
if (region_chooser == NULL )
{
*path_address = region_chooser->get_path();
}
else
{
Cmiss_region_get_root_region_path(path_address);
}
return 1;
}
void wx_Node_tool_set_region_path(char *path)
{
if (path && (region_chooser != NULL))
{
/* path must start with '/' to match items in chooser */
if (path[0] != '/')
{
char *temp = NULL;
if (ALLOCATE(temp,char,strlen(path)+2))
{
strcpy(temp, "/");
strcat(temp, path);
region_chooser->set_path(temp);
DEALLOCATE(temp);
}
else
{
display_message(ERROR_MESSAGE,
"wx_Node_tool_set_region_path. Insufficient memory");
}
}
else
{
region_chooser->set_path(path);
}
}
}
struct Cmiss_region *wx_Node_tool_get_region()
{
if (region_chooser)
{
return (region_chooser->get_region());
}
else
{
return (node_tool->root_region);
}
}
DECLARE_DYNAMIC_CLASS(wxNodeTool);
DECLARE_EVENT_TABLE();
};
IMPLEMENT_DYNAMIC_CLASS(wxNodeTool, wxPanel)
BEGIN_EVENT_TABLE(wxNodeTool, wxPanel)
EVT_CHECKBOX(XRCID("ButtonSelect"),wxNodeTool::OnButtonSelectpressed)
EVT_CHECKBOX(XRCID("ButtonEdit"),wxNodeTool::OnButtonEditpressed)
EVT_CHECKBOX(XRCID("ButtonMotionUpdate"),wxNodeTool::OnButtonMotionUpdatepressed)
EVT_CHECKBOX(XRCID("ButtonDefine"),wxNodeTool::OnButtonDefinepressed)
EVT_CHECKBOX(XRCID("ButtonCreate"),wxNodeTool::OnButtonCreatepressed)
EVT_CHECKBOX(XRCID("ButtonStreaming"),wxNodeTool::OnButtonStreamingpressed)
EVT_CHECKBOX(XRCID("ButtonConstrain"),wxNodeTool::OnButtonConstrainpressed)
EVT_CHECKBOX(XRCID("ElementXiFieldCheckBox"),wxNodeTool::ElementXiFieldChecked)
EVT_CHECKBOX(XRCID("NodeCommandFieldCheckBox"),wxNodeTool::NodeCommandFieldChecked)
EVT_BUTTON(XRCID("ButtonDestroy"),wxNodeTool::OnButtonDestroypressed)
EVT_BUTTON(XRCID("ButtonUndefine"),wxNodeTool::OnButtonUndefinepressed)
EVT_BUTTON(XRCID("ClearButton"),wxNodeTool::OnClearButtonpressed)
EVT_CHECKBOX(XRCID("CreateElementsCheckBox"),wxNodeTool::OnCreateElementsPressed)
EVT_TEXT_ENTER(XRCID("DimensionTextCtrl"),wxNodeTool::OnDimensionEntered)
END_EVENT_TABLE()
#endif /* defined (WX_USER_INTERFACE) */
/*
Global functions
----------------
*/
#if defined (WX_USER_INTERFACE)
void Node_tool_set_wx_interface(void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 13 April 2007
DESCRIPTION :
Set the wx_interface for new settings.
==============================================================================*/
{
struct Node_tool *node_tool;
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (node_tool->wx_node_tool != (wxNodeTool *) NULL)
{
node_tool->wx_node_tool->NodeToolInterfaceRenew(node_tool);
}
}
}
#endif /*(WX_USER_INTERFACE)*/
static int Node_tool_copy_function(
void *destination_tool_void, void *source_tool_void,
struct MANAGER(Interactive_tool) *destination_tool_manager)
/*******************************************************************************
LAST MODIFIED : 29 March 2007
DESCRIPTION :
Copies the state of one node tool to another.
==============================================================================*/
{
int return_code;
struct Node_tool *destination_node_tool, *source_node_tool;
ENTER(Node_tool_copy_function);
if ((destination_tool_void || destination_tool_manager) &&
(source_node_tool=(struct Node_tool *)source_tool_void))
{
if (destination_tool_void)
{
destination_node_tool = (struct Node_tool *)destination_tool_void;
}
else
{
destination_node_tool = CREATE(Node_tool)(
destination_tool_manager,
source_node_tool->root_region,
source_node_tool->use_data,
source_node_tool->node_selection,
source_node_tool->computed_field_package,
source_node_tool->rubber_band_material,
source_node_tool->user_interface,
source_node_tool->time_keeper,
source_node_tool->execute_command);
}
if (destination_node_tool)
{
destination_node_tool->coordinate_field = source_node_tool->coordinate_field;
destination_node_tool->create_enabled = source_node_tool->create_enabled;
destination_node_tool->define_enabled = source_node_tool->define_enabled;
destination_node_tool->edit_enabled= source_node_tool->edit_enabled;
destination_node_tool->motion_update_enabled= source_node_tool->motion_update_enabled;
destination_node_tool->select_enabled = source_node_tool->select_enabled;
destination_node_tool->streaming_create_enabled = source_node_tool->streaming_create_enabled;
destination_node_tool->constrain_to_surface= source_node_tool->constrain_to_surface;
destination_node_tool->command_field = source_node_tool->command_field;
destination_node_tool->element_xi_field = source_node_tool->element_xi_field;
#if ! defined (MOTIF)
destination_node_tool->current_region_path= source_node_tool->current_region_path;
#endif /* ! defined (MOTIF) */
destination_node_tool->element_create_enabled = source_node_tool->element_create_enabled;
destination_node_tool->element_dimension = source_node_tool->element_dimension;
Node_tool_set_Cmiss_region(destination_node_tool,
source_node_tool->region);
#if defined (WX_USER_INTERFACE)
if (destination_node_tool->wx_node_tool != (wxNodeTool *) NULL)
{
destination_node_tool->wx_node_tool->NodeToolInterfaceRenew(destination_node_tool);
}
return_code=1;
#endif /*(WX_USER_INTERFACE)*/
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_copy_function. Could not create copy.");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_copy_function. Invalid argument(s)");
return_code=0;
}
return (return_code);
} /* Node_tool_copy_function */
struct Node_tool *CREATE(Node_tool)(
struct MANAGER(Interactive_tool) *interactive_tool_manager,
struct Cmiss_region *root_region, int use_data,
struct FE_node_selection *node_selection,
struct Computed_field_package *computed_field_package,
struct Graphical_material *rubber_band_material,
struct User_interface *user_interface,
struct Time_keeper *time_keeper,
struct Execute_command *execute_command)
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Creates a Node_tool for editing nodes/data in the <node_manager>,
using the <node_selection>.
The <use_data> flag indicates that <node_manager> and <node_selection>
refer to data, not nodes, needed since different GT_element_settings types are
used to represent them. <element_manager> should be NULL if <use_data> is true.
==============================================================================*/
{
char *initial_path;
char *tool_display_name,*tool_name;
#if defined (MOTIF)
Atom WM_DELETE_WINDOW;
int init_widgets;
MrmType node_tool_dialog_class;
static MrmRegisterArg callback_list[]=
{
{"node_tool_id_select_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,select_button)},
{"node_tool_id_edit_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,edit_button)},
{"node_tool_id_motion_update_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,motion_update_button)},
{"node_tool_id_define_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,define_button)},
{"node_tool_id_create_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,create_button)},
{"node_tool_id_streaming_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,streaming_create_button)},
{"node_tool_id_constrain_srf_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,constrain_to_surface_button)},
{"node_tool_id_node_group_form",(XtPointer)
DIALOG_IDENTIFY(node_tool,node_group_form)},
{"node_tool_id_coord_field_form",(XtPointer)
DIALOG_IDENTIFY(node_tool,coordinate_field_form)},
{"node_tool_id_command_field_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,command_field_button)},
{"node_tool_id_command_field_form",(XtPointer)
DIALOG_IDENTIFY(node_tool,command_field_form)},
{"node_tool_select_btn_CB",
(XtPointer)Node_tool_select_button_CB},
{"node_tool_edit_btn_CB",
(XtPointer)Node_tool_edit_button_CB},
{"node_tool_motion_update_btn_CB",
(XtPointer)Node_tool_motion_update_button_CB},
{"node_tool_define_btn_CB",
(XtPointer)Node_tool_define_button_CB},
{"node_tool_create_btn_CB",
(XtPointer)Node_tool_create_button_CB},
{"node_tool_streaming_btn_CB",
(XtPointer)Node_tool_streaming_create_button_CB},
{"node_tool_constrain_srf_btn_CB",
(XtPointer)Node_tool_constrain_to_surface_button_CB},
{"node_tool_command_field_btn_CB",
(XtPointer)Node_tool_command_field_button_CB},
{"node_tool_destroy_selected_CB",
(XtPointer)Node_tool_destroy_selected_CB},
{"node_tool_undefine_selected_CB",
(XtPointer)Node_tool_undefine_selected_CB}
};
static MrmRegisterArg identifier_list[]=
{
{"node_tool_structure",(XtPointer)NULL}
};
struct Callback_data callback;
struct Cmiss_region *region;
#endif /* defined (MOTIF) */
struct MANAGER(Computed_field) *computed_field_manager;
struct Node_tool *node_tool;
ENTER(CREATE(Node_tool));
node_tool=(struct Node_tool *)NULL;
if (interactive_tool_manager&&root_region&&node_selection&&
computed_field_package&&(computed_field_manager=
Computed_field_package_get_computed_field_manager(computed_field_package))
&&rubber_band_material&&user_interface&&execute_command)
{
Cmiss_region_get_root_region_path(&initial_path);
if (ALLOCATE(node_tool,struct Node_tool,1))
{
node_tool->execute_command=execute_command;
node_tool->interactive_tool_manager=interactive_tool_manager;
node_tool->root_region=root_region;
node_tool->region=(struct Cmiss_region *)NULL;
node_tool->fe_region=(struct FE_region *)NULL;
node_tool->use_data = use_data;
node_tool->node_selection=node_selection;
node_tool->computed_field_package=computed_field_package;
node_tool->rubber_band_material=
ACCESS(Graphical_material)(rubber_band_material);
node_tool->user_interface=user_interface;
node_tool->time_keeper = (struct Time_keeper *)NULL;
if (time_keeper)
{
node_tool->time_keeper = ACCESS(Time_keeper)(time_keeper);
}
/* user-settable flags */
node_tool->select_enabled=1;
node_tool->edit_enabled=0;
node_tool->motion_update_enabled=1;
node_tool->define_enabled=0;
node_tool->create_enabled=0;
node_tool->streaming_create_enabled=0;
node_tool->constrain_to_surface=0;
/* settings of the element creator */
node_tool->FE_coordinate_field = (struct FE_field *)NULL;
node_tool->element_dimension = 2;
node_tool->template_element = (struct FE_element *)NULL;
node_tool->element_create_enabled = 0;
node_tool->element = (struct FE_element *)NULL;
node_tool->number_of_clicked_nodes = 0;
node_tool->edit_mode=NODE_TOOL_EDIT_AUTOMATIC;
node_tool->coordinate_field =
FIRST_OBJECT_IN_MANAGER_THAT(Computed_field)(
Computed_field_has_up_to_3_numerical_components, (void *)NULL,
computed_field_manager);
node_tool->command_field = (struct Computed_field *)NULL;
node_tool->element_xi_field = (struct Computed_field *)NULL;
/* interactive_tool */
if (use_data)
{
tool_name="data_tool";
tool_display_name="Data tool";
}
else
{
tool_name="node_tool";
tool_display_name="Node tool";
}
#if defined (WX_USER_INTERFACE) /* switch (USER_INTERFACE) */
node_tool->computed_field_manager=Computed_field_package_get_computed_field_manager(computed_field_package);
node_tool->wx_node_tool = (wxNodeTool *)NULL;
/* Set defaults until we have some sort of region chooser */
Node_tool_set_Cmiss_region(node_tool, node_tool->root_region);
node_tool->current_region_path = (char *)NULL;
node_tool->tool_position=wxPoint(0,0);
#elif !defined (MOTIF)
node_tool->current_region_path = (char *)NULL;
#endif /*defined (WX_USER_INTERFACE)*/
node_tool->interactive_tool=CREATE(Interactive_tool)(
tool_name,tool_display_name,
Interactive_tool_node_type_string,
Node_tool_interactive_event_handler,
Node_tool_get_icon,
Node_tool_bring_up_interactive_tool_dialog,
Node_tool_reset,
#if defined (WX_USER_INTERFACE)
Node_tool_destroy_node_tool,
#else
(Interactive_tool_destroy_tool_data_function *)NULL,
#endif /*defined (WX_USER_INTERFACE)*/
Node_tool_copy_function,
(void *)node_tool);
ADD_OBJECT_TO_MANAGER(Interactive_tool)(
node_tool->interactive_tool,
node_tool->interactive_tool_manager);
node_tool->scene_picked_object=(struct Scene_picked_object *)NULL;
node_tool->last_picked_node=(struct FE_node *)NULL;
node_tool->gt_element_group=(struct GT_element_group *)NULL;
node_tool->gt_element_settings=(struct GT_element_settings *)NULL;
node_tool->last_interaction_volume=(struct Interaction_volume *)NULL;
node_tool->rubber_band=(struct GT_object *)NULL;
#if defined (MOTIF)
/* initialise widgets */
node_tool->coordinate_field_form=(Widget)NULL;
node_tool->coordinate_field_widget=(Widget)NULL;
node_tool->cmiss_region_chooser=(struct Cmiss_region_chooser *)NULL;
node_tool->create_button=(Widget)NULL;
node_tool->define_button=(Widget)NULL;
node_tool->display = User_interface_get_display(user_interface);
node_tool->edit_button=(Widget)NULL;
node_tool->motion_update_button=(Widget)NULL;
node_tool->node_group_form=(Widget)NULL;
node_tool->node_group_widget=(Widget)NULL;
node_tool->select_button=(Widget)NULL;
node_tool->streaming_create_button=(Widget)NULL;
node_tool->constrain_to_surface_button=(Widget)NULL;
node_tool->command_field_button=(Widget)NULL;
node_tool->command_field_form=(Widget)NULL;
node_tool->command_field_widget=(Widget)NULL;
node_tool->widget=(Widget)NULL;
node_tool->window_shell=(Widget)NULL;
/* make the dialog shell */
if (MrmOpenHierarchy_binary_string(node_tool_uidh,sizeof(node_tool_uidh),
&node_tool_hierarchy,&node_tool_hierarchy_open))
{
if (node_tool->window_shell=
XtVaCreatePopupShell(tool_display_name,
topLevelShellWidgetClass,
User_interface_get_application_shell(user_interface),
XmNdeleteResponse,XmDO_NOTHING,
XmNmwmDecorations,MWM_DECOR_ALL,
XmNmwmFunctions,MWM_FUNC_ALL,
/*XmNtransient,FALSE,*/
XmNallowShellResize,False,
XmNtitle,tool_display_name,
NULL))
{
/* Set up window manager callback for close window message */
WM_DELETE_WINDOW=XmInternAtom(XtDisplay(node_tool->window_shell),
"WM_DELETE_WINDOW",False);
XmAddWMProtocolCallback(node_tool->window_shell,
WM_DELETE_WINDOW,Node_tool_close_CB,node_tool);
/* Register the shell with the busy signal list */
create_Shell_list_item(&(node_tool->window_shell),user_interface);
/* register the callbacks */
if (MrmSUCCESS==MrmRegisterNamesInHierarchy(
node_tool_hierarchy,callback_list,XtNumber(callback_list)))
{
/* assign and register the identifiers */
identifier_list[0].value=(XtPointer)node_tool;
if (MrmSUCCESS==MrmRegisterNamesInHierarchy(
node_tool_hierarchy,identifier_list,XtNumber(identifier_list)))
{
/* fetch node tool widgets */
if (MrmSUCCESS==MrmFetchWidget(node_tool_hierarchy,
"node_tool",node_tool->window_shell,
&(node_tool->widget),&node_tool_dialog_class))
{
init_widgets=1;
if (node_tool->coordinate_field_widget=
CREATE_CHOOSE_OBJECT_WIDGET(Computed_field)(
node_tool->coordinate_field_form,
node_tool->coordinate_field,computed_field_manager,
Computed_field_has_up_to_3_numerical_components,
(void *)NULL, user_interface))
{
callback.data=(void *)node_tool;
callback.procedure=Node_tool_update_coordinate_field;
CHOOSE_OBJECT_SET_CALLBACK(Computed_field)(
node_tool->coordinate_field_widget,&callback);
}
else
{
init_widgets=0;
}
if (node_tool->command_field_widget =
CREATE_CHOOSE_OBJECT_WIDGET(Computed_field)(
node_tool->command_field_form,
node_tool->command_field, computed_field_manager,
Computed_field_has_string_value_type,
(void *)NULL, user_interface))
{
callback.data = (void *)node_tool;
callback.procedure = Node_tool_update_command_field;
CHOOSE_OBJECT_SET_CALLBACK(Computed_field)(
node_tool->command_field_widget, &callback);
}
else
{
init_widgets=0;
}
if (node_tool->cmiss_region_chooser =
CREATE(Cmiss_region_chooser)(node_tool->node_group_form,
node_tool->root_region, initial_path))
{
if (Cmiss_region_chooser_get_region(
node_tool->cmiss_region_chooser, ®ion))
{
Node_tool_set_Cmiss_region(node_tool, region);
}
Cmiss_region_chooser_set_callback(
node_tool->cmiss_region_chooser,
Node_tool_update_region,
(void *)node_tool);
}
else
{
init_widgets=0;
}
if (init_widgets)
{
XmToggleButtonGadgetSetState(node_tool->create_button,
/*state*/node_tool->create_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->define_button,
/*state*/node_tool->define_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->edit_button,
/*state*/node_tool->edit_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->motion_update_button,
/*state*/node_tool->motion_update_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->select_button,
/*state*/node_tool->select_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(
node_tool->streaming_create_button,
/*state*/node_tool->streaming_create_enabled,
/*notify*/False);
XmToggleButtonGadgetSetState(
node_tool->constrain_to_surface_button,
/*state*/node_tool->constrain_to_surface,
/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->command_field_button,
/*state*/False, /*notify*/False);
XtSetSensitive(node_tool->command_field_widget, /*state*/False);
XtManageChild(node_tool->widget);
XtRealizeWidget(node_tool->window_shell);
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not init widgets");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not fetch node_tool");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not register identifiers");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not register callbacks");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not create Shell");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not open hierarchy");
}
#endif /* defined (USER_INTERFACE) */
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Not enough memory");
DEALLOCATE(node_tool);
}
DEALLOCATE(initial_path);
}
else
{
display_message(ERROR_MESSAGE,"CREATE(Node_tool). Invalid argument(s)");
}
LEAVE;
return (node_tool);
} /* CREATE(Node_tool) */
int DESTROY(Node_tool)(struct Node_tool **node_tool_address)
/*******************************************************************************
LAST MODIFIED : 19 July 2000
DESCRIPTION :
Frees and deaccesses objects in the <node_tool> and deallocates the
structure itself.
==============================================================================*/
{
struct Node_tool *node_tool;
int return_code;
ENTER(DESTROY(Node_tool));
if (node_tool_address&&
(node_tool= *node_tool_address))
{
#if defined (MOTIF)
REMOVE_OBJECT_FROM_MANAGER(Interactive_tool)(
node_tool->interactive_tool,
node_tool->interactive_tool_manager);
#endif /* defined (MOTIF) */
Node_tool_reset((void *)node_tool);
REACCESS(GT_object)(&(node_tool->rubber_band),(struct GT_object *)NULL);
DEACCESS(Graphical_material)(&(node_tool->rubber_band_material));
if (node_tool->time_keeper)
{
DEACCESS(Time_keeper)(&(node_tool->time_keeper));
}
#if defined (WX_USER_INTERFACE)
if (node_tool->wx_node_tool)
node_tool->wx_node_tool->Destroy();
#endif /*(WX_USER_INTERFACE)*/
#if defined (MOTIF)
if (node_tool->window_shell)
{
destroy_Shell_list_item_from_shell(&(node_tool->window_shell),
node_tool->user_interface);
XtDestroyWidget(node_tool->window_shell);
}
#elif !defined (WX_USER_INTERFACE)
if (node_tool->current_region_path != NULL)
{
DEALLOCATE(node_tool->current_region_path);
}
#endif /* defined (MOTIF) */
DEALLOCATE(*node_tool_address);
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,"DESTROY(Node_tool). Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* DESTROY(Node_tool) */
int Node_tool_pop_up_dialog(struct Node_tool *node_tool, struct Graphics_window *graphics_window)
/*******************************************************************************
LAST MODIFIED : 20 June 2001
DESCRIPTION :
Pops up a dialog for editing settings of the Node_tool.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_pop_up_dialog);
if (node_tool)
{
#if defined (MOTIF)
XtPopup(node_tool->window_shell, XtGrabNone);
/* make sure in addition that it is not shown as an icon */
XtVaSetValues(node_tool->window_shell, XmNiconic, False, NULL);
#elif defined (WX_USER_INTERFACE) /* switch (USER_INTERFACE) */
wxPanel *pane;
if (!node_tool->wx_node_tool)
{
wxScrolledWindow *GeneralSettingPanel = Graphics_window_get_interactive_tool_panel(graphics_window);
node_tool->wx_node_tool = new wxNodeTool(node_tool,
GeneralSettingPanel);
pane = XRCCTRL(*node_tool->wx_node_tool, "CmguiNodeTool", wxPanel);
node_tool->tool_position = pane->GetPosition();
node_tool->wx_node_tool->Show();
}
else
{
pane = XRCCTRL(*node_tool->wx_node_tool, "CmguiNodeTool", wxPanel);
pane->SetPosition(node_tool->tool_position);
node_tool->wx_node_tool->Show();
}
#else /* switch (USER_INTERFACE) */
display_message(ERROR_MESSAGE, "Node_tool_pop_up_dialog. "
"No dialog implemented for this User Interface");
#endif /* switch (USER_INTERFACE) */
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_pop_up_dialog. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_pop_up_dialog */
int Node_tool_pop_down_dialog(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 20 June 2001
DESCRIPTION :
Hides the dialog for editing settings of the Node_tool.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_pop_down_dialog);
if (node_tool)
{
#if defined (MOTIF)
XtPopdown(node_tool->window_shell);
#else /* defined (MOTIF) */
display_message(ERROR_MESSAGE, "Node_tool_pop_down_dialog. "
"No dialog implemented for this User Interface");
#endif /* defined (MOTIF) */
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_pop_down_dialog. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_pop_down_dialog */
struct Computed_field *Node_tool_get_coordinate_field(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Returns the coordinate_field used by the <node_tool> when create/define are on.
==============================================================================*/
{
struct Computed_field *coordinate_field;
ENTER(Node_tool_get_coordinate_field);
if (node_tool)
{
coordinate_field=node_tool->coordinate_field;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_coordinate_field. Invalid argument(s)");
coordinate_field=(struct Computed_field *)NULL;
}
LEAVE;
return (coordinate_field);
} /* Node_tool_get_coordinate_field */
int Node_tool_set_coordinate_field(struct Node_tool *node_tool,
struct Computed_field *coordinate_field)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Sets the coordinate_field to be defined by the <node_tool> when create/define
are on.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_coordinate_field);
if (node_tool)
{
return_code=1;
if (coordinate_field != node_tool->coordinate_field)
{
node_tool->coordinate_field=coordinate_field;
#if defined (MOTIF)
/* make sure the current field is shown on the widget */
CHOOSE_OBJECT_SET_OBJECT(Computed_field)(
node_tool->coordinate_field_widget,node_tool->coordinate_field);
#endif /* defined (MOTIF) */
#if defined (WX_USER_INTERFACE)
if (node_tool->wx_node_tool)
{
node_tool->wx_node_tool->setCoordinateField(coordinate_field);
}
#endif /* defined (WX_USER_INTERFACE) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_coordinate_field. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_coordinate_field */
int Node_tool_get_create_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Returns flag controlling whether nodes can be created when none are selected
on a mouse button press.
==============================================================================*/
{
int create_enabled;
ENTER(Node_tool_get_create_enabled);
if (node_tool)
{
create_enabled=node_tool->create_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_create_enabled. Invalid argument(s)");
create_enabled=0;
}
LEAVE;
return (create_enabled);
} /* Node_tool_get_create_enabled */
int Node_tool_set_create_enabled(struct Node_tool *node_tool,
int create_enabled)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Sets flag controlling whether nodes can be created when none are selected
on a mouse button press. Also ensures define is enabled if create is.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_create_enabled);
if (node_tool)
{
return_code=1;
if (create_enabled)
{
if (node_tool->region && node_tool->coordinate_field)
{
/* make sure value of flag is exactly 1 */
create_enabled=1;
/* must also enable define */
Node_tool_set_define_enabled(node_tool,1);
}
else
{
display_message(WARNING_MESSAGE,
"Node_tool must have a group and coordinate_field to create nodes");
create_enabled=0;
return_code=0;
}
}
if (create_enabled != node_tool->create_enabled)
{
node_tool->create_enabled=create_enabled;
/* make sure button shows current state */
#if defined (MOTIF)
if (XmToggleButtonGadgetGetState(node_tool->create_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->create_enabled)
{
XmToggleButtonGadgetSetState(node_tool->create_button,
/*state*/node_tool->create_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_create_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_create_enabled */
int Node_tool_get_define_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Returns flag controlling whether nodes can be defined when none are selected
on a mouse button press.
==============================================================================*/
{
int define_enabled;
ENTER(Node_tool_get_define_enabled);
if (node_tool)
{
define_enabled=node_tool->define_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_define_enabled. Invalid argument(s)");
define_enabled=0;
}
LEAVE;
return (define_enabled);
} /* Node_tool_get_define_enabled */
int Node_tool_set_define_enabled(struct Node_tool *node_tool,
int define_enabled)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Sets flag controlling whether the coordinate_field can be defined on any new
or individually selected existing nodes.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_define_enabled);
if (node_tool)
{
return_code=1;
if (define_enabled)
{
if (node_tool->coordinate_field)
{
/* make sure value of flag is exactly 1 */
define_enabled=1;
}
else
{
display_message(WARNING_MESSAGE,
"Cannot enable define in Node_tool without a field to define");
define_enabled=0;
return_code=0;
}
}
else
{
/* make sure create is off */
Node_tool_set_create_enabled(node_tool,0);
}
if (define_enabled != node_tool->define_enabled)
{
node_tool->define_enabled=define_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->define_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->define_enabled)
{
XmToggleButtonGadgetSetState(node_tool->define_button,
/*state*/node_tool->define_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_define_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_define_enabled */
int Node_tool_get_edit_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int edit_enabled;
ENTER(Node_tool_get_edit_enabled);
if (node_tool)
{
edit_enabled=node_tool->edit_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_edit_enabled. Invalid argument(s)");
edit_enabled=0;
}
LEAVE;
return (edit_enabled);
} /* Node_tool_get_edit_enabled */
int Node_tool_set_edit_enabled(struct Node_tool *node_tool,int edit_enabled)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Sets flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_edit_enabled);
if (node_tool)
{
/* make sure value of flag is 1 */
if (edit_enabled)
{
edit_enabled=1;
}
if (edit_enabled != node_tool->edit_enabled)
{
node_tool->edit_enabled=edit_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->edit_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->edit_enabled)
{
XmToggleButtonGadgetSetState(node_tool->edit_button,
/*state*/node_tool->edit_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_edit_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_edit_enabled */
enum Node_tool_edit_mode Node_tool_get_edit_mode(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns the current edit mode of <node_tool>.
==============================================================================*/
{
enum Node_tool_edit_mode edit_mode;
ENTER(Node_tool_get_edit_mode);
if (node_tool)
{
edit_mode=node_tool->edit_mode;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_edit_mode. Invalid argument(s)");
/* return anything for error condition */
edit_mode=NODE_TOOL_EDIT_AUTOMATIC;
}
LEAVE;
return (edit_mode);
} /* Node_tool_get_edit_mode */
int Node_tool_set_edit_mode(struct Node_tool *node_tool,
enum Node_tool_edit_mode edit_mode)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Sets the <edit_mode> of <node_tool> - controls whether the editor
can select or edit nodes, and whether the editing is restricted to position or
vector only.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_edit_mode);
if (node_tool)
{
node_tool->edit_mode=edit_mode;
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_edit_mode. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_edit_mode */
int Node_tool_get_motion_update_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int motion_update_enabled;
ENTER(Node_tool_get_motion_update_enabled);
if (node_tool)
{
motion_update_enabled=node_tool->motion_update_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_motion_update_enabled. Invalid argument(s)");
motion_update_enabled=0;
}
LEAVE;
return (motion_update_enabled);
} /* Node_tool_get_motion_update_enabled */
int Node_tool_set_motion_update_enabled(struct Node_tool *node_tool,
int motion_update_enabled)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Sets flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_motion_update_enabled);
if (node_tool)
{
/* make sure value of flag is 1 */
if (motion_update_enabled)
{
motion_update_enabled=1;
}
if (motion_update_enabled != node_tool->motion_update_enabled)
{
node_tool->motion_update_enabled=motion_update_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->motion_update_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->motion_update_enabled)
{
XmToggleButtonGadgetSetState(node_tool->motion_update_button,
/*state*/node_tool->motion_update_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_motion_update_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_motion_update_enabled */
int Node_tool_get_region_path(struct Node_tool *node_tool,
char **path_address)
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Returns in <path_address> the path to the Cmiss_region where nodes created by
the <node_tool> are put.
Up to the calling function to DEALLOCATE the returned path.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_get_region_path);
if (node_tool && path_address)
{
#if defined (MOTIF)
return_code = Cmiss_region_chooser_get_path(node_tool->cmiss_region_chooser,
path_address);
#elif defined (WX_USER_INTERFACE)
if (node_tool->current_region_path)
{
*path_address = duplicate_string(node_tool->current_region_path);
return_code = 1;
}
else
{
Cmiss_region_get_root_region_path(path_address);
return_code = 0;
}
#else /* switch USER_INTERFACE*/
if (node_tool->current_region_path)
{
*path_address = duplicate_string(node_tool->current_region_path);
return_code = 1;
}
else
{
*path_address = (char *)NULL;
return_code = 0;
}
#endif /* defined (MOTIF) */
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_region_path. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_get_region_path */
#if defined (WX_USER_INTERFACE)
char *Node_tool_get_current_region_path(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 10 July 2007
DESCRIPTION :
Return the pointer of the node_tool->current_region_path, used for
deallocate the current region path outside whe cmiss command_data is
being destroy to prevent multiple deallocations of the same address.
==============================================================================*/
{
ENTER(Node_tool_get_region_path);
char *path;
path = NULL;
if (node_tool)
{
if (node_tool->current_region_path)
{
path = node_tool->current_region_path;
}
}
return (path);
}
#endif /* defined (WX_USER_INTERFACE) */
int Node_tool_set_region_path(struct Node_tool *node_tool,
char *path)
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Sets the <path> to the region/FE_region where nodes created by
<node_tool> are placed.
==============================================================================*/
{
int return_code;
struct Cmiss_region *region;
ENTER(Node_tool_set_region_path);
if (node_tool && path)
{
#if defined (MOTIF)
Cmiss_region_chooser_set_path(node_tool->cmiss_region_chooser, path);
region = (struct Cmiss_region *)NULL;
Cmiss_region_chooser_get_region(node_tool->cmiss_region_chooser, ®ion);
return_code = Node_tool_set_Cmiss_region(node_tool, region);
#elif defined (WX_USER_INTERFACE)
if (node_tool->current_region_path)
{
DEALLOCATE(node_tool->current_region_path);
}
node_tool->current_region_path = duplicate_string(path);
region = (struct Cmiss_region *)NULL;
if (node_tool->wx_node_tool)
{
node_tool->wx_node_tool->wx_Node_tool_set_region_path(path);
region = node_tool->wx_node_tool->wx_Node_tool_get_region();
}
else
{
region=node_tool->root_region;
Cmiss_region_get_region_from_path(node_tool->root_region,
path, ®ion);
}
return_code = Node_tool_set_Cmiss_region(node_tool, region);
#else /* defined (MOTIF) */
if (return_code = Cmiss_region_get_region_from_path(node_tool->root_region,
path, ®ion))
{
if (node_tool->current_region_path)
{
DEALLOCATE(node_tool->current_region_path);
}
node_tool->current_region_path = duplicate_string(path);
return_code = Node_tool_set_Cmiss_region(node_tool, region);
}
#endif /* defined (MOTIF) */
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_region_path. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_region_path */
int Node_tool_get_select_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns flag controlling whether existing nodes can be selected.
==============================================================================*/
{
int select_enabled;
ENTER(Node_tool_get_select_enabled);
if (node_tool)
{
select_enabled=node_tool->select_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_select_enabled. Invalid argument(s)");
select_enabled=0;
}
LEAVE;
return (select_enabled);
} /* Node_tool_get_select_enabled */
int Node_tool_set_select_enabled(struct Node_tool *node_tool,
int select_enabled)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Sets flag controlling whether existing nodes can be selected.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_select_enabled);
if (node_tool)
{
/* make sure value of flag is 1 */
if (select_enabled)
{
select_enabled=1;
}
if (select_enabled != node_tool->select_enabled)
{
node_tool->select_enabled=select_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->select_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->select_enabled)
{
XmToggleButtonGadgetSetState(node_tool->select_button,
/*state*/node_tool->select_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_select_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_select_enabled */
int Node_tool_get_streaming_create_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 14 May 2001
DESCRIPTION :
Returns flag controlling, if create_enabled, whether a stream of nodes is
created as the user drags the mouse around.
==============================================================================*/
{
int streaming_create_enabled;
ENTER(Node_tool_get_streaming_create_enabled);
if (node_tool)
{
streaming_create_enabled = node_tool->streaming_create_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_streaming_create_enabled. Invalid argument(s)");
streaming_create_enabled = 0;
}
LEAVE;
return (streaming_create_enabled);
} /* Node_tool_get_streaming_create_enabled */
int Node_tool_set_streaming_create_enabled(struct Node_tool *node_tool,
int streaming_create_enabled)
/*******************************************************************************
LAST MODIFIED : 14 May 2001
DESCRIPTION :
Sets flag controlling, if create_enabled, whether a stream of nodes is
created as the user drags the mouse around.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_streaming_create_enabled);
if (node_tool)
{
if (streaming_create_enabled)
{
/* make sure value of flag is exactly 1 */
streaming_create_enabled = 1;
}
if (streaming_create_enabled != node_tool->streaming_create_enabled)
{
node_tool->streaming_create_enabled = streaming_create_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->streaming_create_button))
{
button_state = 1;
}
else
{
button_state = 0;
}
if (button_state != node_tool->streaming_create_enabled)
{
XmToggleButtonGadgetSetState(node_tool->streaming_create_button,
/*state*/node_tool->streaming_create_enabled, /*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_streaming_create_enabled. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_streaming_create_enabled */
int Node_tool_get_constrain_to_surface(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 April 2005
DESCRIPTION :
Returns flag controlling, if create_enabled, whether new nodes will be created
on the closest surface element or just halfway between near and far.
==============================================================================*/
{
int constrain_to_surface;
ENTER(Node_tool_get_constrain_to_surface);
if (node_tool)
{
constrain_to_surface = node_tool->constrain_to_surface;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_constrain_to_surface. Invalid argument(s)");
constrain_to_surface = 0;
}
LEAVE;
return (constrain_to_surface);
} /* Node_tool_get_constrain_to_surface */
int Node_tool_set_constrain_to_surface(struct Node_tool *node_tool,
int constrain_to_surface)
/*******************************************************************************
LAST MODIFIED : 18 April 2005
DESCRIPTION :
Sets flag controlling, if create_enabled, whether new nodes will be created
on the closest surface element or just halfway between near and far.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_constrain_to_surface);
if (node_tool)
{
if (constrain_to_surface)
{
/* make sure value of flag is exactly 1 */
constrain_to_surface = 1;
}
if (constrain_to_surface != node_tool->constrain_to_surface)
{
node_tool->constrain_to_surface = constrain_to_surface;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->constrain_to_surface_button))
{
button_state = 1;
}
else
{
button_state = 0;
}
if (button_state != node_tool->constrain_to_surface)
{
XmToggleButtonGadgetSetState(node_tool->constrain_to_surface_button,
/*state*/node_tool->constrain_to_surface, /*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_constrain_to_surface. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_constrain_to_surface */
struct Computed_field *Node_tool_get_element_xi_field(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 February 2008
DESCRIPTION :
Returns the element_xi_field to define when the node is created in the <node_tool>
and node is constrained to surface.
==============================================================================*/
{
struct Computed_field *element_xi_field;
ENTER(Node_tool_get_element_xi_field);
if (node_tool)
{
element_xi_field=node_tool->element_xi_field;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_element_xi_field. Invalid argument(s)");
element_xi_field=(struct Computed_field *)NULL;
}
LEAVE;
return (element_xi_field);
} /* Node_tool_get_element_xi_field */
int Node_tool_set_element_xi_field(struct Node_tool *node_tool,
struct Computed_field *element_xi_field)
/*******************************************************************************
LAST MODIFIED : 19 February 2008
DESCRIPTION :
Sets the element_xi_field to define when the node is created in the <node_tool>
and node is constrained to surface.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_element_xi_field);
if (node_tool && ((!element_xi_field) ||
Computed_field_has_element_xi_fe_field(element_xi_field, (void *)NULL)))
{
if (element_xi_field != node_tool->element_xi_field)
{
node_tool->element_xi_field = element_xi_field;
}
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_element_xi_field. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_element_xi_field */
struct Computed_field *Node_tool_get_command_field(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Returns the command_field to be exectued when the node is clicked on in the <node_tool>.
==============================================================================*/
{
struct Computed_field *command_field;
ENTER(Node_tool_get_command_field);
if (node_tool)
{
command_field=node_tool->command_field;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_command_field. Invalid argument(s)");
command_field=(struct Computed_field *)NULL;
}
LEAVE;
return (command_field);
} /* Node_tool_get_command_field */
int Node_tool_set_command_field(struct Node_tool *node_tool,
struct Computed_field *command_field)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Sets the command_field to be executed when the node is clicked on in the <node_tool>.
==============================================================================*/
{
#if defined (MOTIF)
int field_set;
#endif /* defined (MOTIF) */
int return_code;
ENTER(Node_tool_set_command_field);
if (node_tool && ((!command_field) ||
Computed_field_has_string_value_type(command_field, (void *)NULL)))
{
return_code = 1;
if (command_field != node_tool->command_field)
{
node_tool->command_field = command_field;
#if defined (MOTIF)
if (command_field)
{
CHOOSE_OBJECT_SET_OBJECT(Computed_field)(
node_tool->command_field_widget,node_tool->command_field);
}
field_set = ((struct Computed_field *)NULL != command_field);
XtVaSetValues(node_tool->command_field_button,
XmNset, field_set, NULL);
XtSetSensitive(node_tool->command_field_widget, field_set);
#endif /* defined (MOTIF) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_command_field. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_command_field */
struct Interactive_tool *Node_tool_get_interactive_tool(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 7 April 2007
DESCRIPTION :
Returns the generic interactive_tool the represents the <node_tool>.
==============================================================================*/
{
struct Interactive_tool *interactive_tool;
ENTER(Node_tool_get_interactive_tool);
if (node_tool)
{
interactive_tool=node_tool->interactive_tool;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_interactive_tool. Invalid argument(s)");
interactive_tool=(struct Interactive_tool *)NULL;
}
LEAVE;
return (interactive_tool);
} /* Node_tool_get_interactive_tool */
#if defined (WX_USER_INTERFACE)
static int Node_tool_end_element_creation(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
DEACCESSes the element being created, if any, and if it is unmanaged, warns that
the creation was aborted. Also clears the node list.
Call this function whether element is successfully created or not.
==============================================================================*/
{
int return_code;
wxListBox *new_element_nodes_list_box;
ENTER(node_tool_end_element_creation);
if (node_tool)
{
if (node_tool->element)
{
if (!FE_region_contains_FE_element(node_tool->fe_region,
node_tool->element))
{
display_message(WARNING_MESSAGE,
"node_tool: destroying incomplete element");
}
DEACCESS(FE_element)(&(node_tool->element));
if (node_tool->wx_node_tool != NULL)
{
new_element_nodes_list_box = XRCCTRL(*node_tool->wx_node_tool, "NewElementNodesListBox", wxListBox);
new_element_nodes_list_box->Clear();
}
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_end_element_creation. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Element_creator_end_element_creation */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
static int Node_tool_add_element(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Adds the just created element to the fe_region, adding faces as necessary.
==============================================================================*/
{
int return_code;
ENTER(node_tool_add_element);
if (node_tool && node_tool->fe_region && node_tool->element)
{
FE_region_begin_change(node_tool->fe_region);
FE_region_begin_define_faces(node_tool->fe_region);
return_code = FE_region_merge_FE_element_and_faces_and_nodes(
node_tool->fe_region, node_tool->element);
FE_region_end_define_faces(node_tool->fe_region);
FE_region_end_change(node_tool->fe_region);
Node_tool_end_element_creation(node_tool);
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_add_element. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* node_tool_add_element */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
static void Node_tool_node_selection_change(
struct FE_node_selection *node_selection,
struct FE_node_selection_changes *changes,void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Callback for change in the global node selection.
==============================================================================*/
{
char temp_string[50];
int number_of_nodes, number;
struct CM_element_information element_identifier;
struct Node_tool *node_tool;
struct FE_node *node;
wxString blank;
wxListBox *new_element_nodes_list_box;
struct FE_field *fe_field;
struct LIST(FE_field) *fe_field_list;
ENTER(node_tool_node_selection_change);
if (node_selection&&changes&&(node_tool=
(struct Node_tool *)node_tool_void))
{
/* if exactly 1 node selected, add it to element */
if (1==NUMBER_IN_LIST(FE_node)(changes->newly_selected_node_list))
{
/* get the last selected node and check it is in the FE_region */
node = FIRST_OBJECT_IN_LIST_THAT(FE_node)(
(LIST_CONDITIONAL_FUNCTION(FE_node) *)NULL,(void *)NULL,
changes->newly_selected_node_list);
if (FE_region_contains_FE_node(node_tool->fe_region, node))
{
if (!node_tool->element)
{
/* get next unused element identifier from fe_region */
element_identifier.type = CM_ELEMENT;
element_identifier.number = FE_region_get_next_FE_element_identifier(
node_tool->fe_region, CM_ELEMENT, 1);
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list)) &&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)) &&
(3 >= get_FE_field_number_of_components(fe_field)) &&
(FE_VALUE_VALUE == get_FE_field_value_type(fe_field)))
{
if (node_tool->template_element ||
(((node_tool->template_element = create_FE_element_with_line_shape(
/*identifier*/1,node_tool->fe_region, node_tool->element_dimension)) &&
FE_element_define_tensor_product_basis(node_tool->template_element,
node_tool->element_dimension,/*basis_type*/LINEAR_LAGRANGE,
fe_field)) &&
ACCESS(FE_element)(node_tool->template_element)))
{
if (node_tool->element = CREATE(FE_element)(&element_identifier,
(struct FE_element_shape *)NULL, (struct FE_region *)NULL,
node_tool->template_element))
{
ACCESS(FE_element)(node_tool->element);
node_tool->number_of_clicked_nodes=0;
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not create element");
}
}
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not create template element");
}
}
if (node_tool->element)
{
/* When we make more than linear elements we will need
to check that the derivatives exist and are the correct ones */
if (set_FE_element_node(node_tool->element,
node_tool->number_of_clicked_nodes,node))
{
if (node_tool->wx_node_tool != NULL)
{
sprintf(temp_string,"%d. Node %d",
node_tool->number_of_clicked_nodes+1,
get_FE_node_identifier(node));
wxString string(temp_string, wxConvUTF8);
new_element_nodes_list_box = XRCCTRL(*node_tool->wx_node_tool, "NewElementNodesListBox", wxListBox);
number = new_element_nodes_list_box->GetCount();
if (number == 0)
{
new_element_nodes_list_box->InsertItems(1, &blank ,number);
}
number = new_element_nodes_list_box->GetCount();
new_element_nodes_list_box->InsertItems(1,&string, number-1);
}
node_tool->number_of_clicked_nodes++;
if (get_FE_element_number_of_nodes(node_tool->element,
&number_of_nodes) &&
(node_tool->number_of_clicked_nodes == number_of_nodes))
{
Node_tool_add_element(node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not set node");
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not create element");
}
}
else
{
display_message(ERROR_MESSAGE,
"Element creator: Selected node not from current region");
}
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Invalid argument(s)");
}
LEAVE;
} /* node_tool_node_selection_change */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_create_enabled(struct Node_tool *node_tool ,
int element_create_enabled)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Sets flag controlling whether elements are created in response to
node selection.
==============================================================================*/
{
int return_code;
ENTER(node_tool_set_create_enabled);
if (node_tool )
{
/* make sure value of flag is 1 */
if (element_create_enabled)
{
element_create_enabled=1;
}
if (element_create_enabled != node_tool ->element_create_enabled)
{
node_tool ->element_create_enabled=element_create_enabled;
if (element_create_enabled)
{
/* request callbacks from the global node_selection */
FE_node_selection_add_callback(node_tool ->node_selection,
Node_tool_node_selection_change,
(void *)node_tool);
}
else
{
Node_tool_end_element_creation(node_tool);
/* end callbacks from the global node_selection */
FE_node_selection_remove_callback(node_tool->node_selection,
Node_tool_node_selection_change,
(void *)node_tool);
}
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"node_tool _set_create_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* node_tool _set_create_enabled */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_dimension(
struct Node_tool *node_tool,int element_dimension)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Sets the <element_dimension> of elements to be created by <node_tool>.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_element_dimension);
if (node_tool)
{
if ((0<element_dimension)&&(element_dimension<=3))
{
return_code=1;
if (node_tool->element_dimension != element_dimension)
{
node_tool->element_dimension=element_dimension;
Node_tool_end_element_creation(node_tool);
/* lose the current template element and node, if any */
REACCESS(FE_element)(&(node_tool->template_element),
(struct FE_element *)NULL);
}
if (node_tool->wx_node_tool != NULL)
{
Node_tool_refresh_element_dimension_text(node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,"Dimension must be from 1 to 3");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_element_dimension. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* node_tool_set_element_dimension */
#endif /* defined (WX_USER_INTERFACE)*/
# if defined (WX_USER_INTERFACE)
static int Node_tool_refresh_element_dimension_text(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Updates what is shown on the dimension text field.
==============================================================================*/
{
char temp_string[20],*value_string;
int return_code;
wxTextCtrl *dimension_textctrl;
dimension_textctrl = XRCCTRL(*node_tool->wx_node_tool, "DimensionTextCtrl", wxTextCtrl);
ENTER(Node_tool_refresh_element_dimension_text);
if (node_tool)
{
return_code=1;
if (value_string=const_cast<char *>((dimension_textctrl->GetValue()).c_str()))
{
sprintf(temp_string,"%d",node_tool->element_dimension);
/* only set string if different from that shown */
if (strcmp(temp_string,value_string))
{
wxString string(temp_string, wxConvUTF8);
dimension_textctrl->SetValue(string);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_refresh_element_dimension_text. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* node_tool_refresh_element_dimension_text */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_get_element_create_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 12 April 2007
DESCRIPTION :
Returns flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int element_create_enabled;
ENTER(Node_tool_get_element_create_enabled);
if (node_tool)
{
element_create_enabled=node_tool->element_create_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_element_create_enabled. Invalid argument(s)");
element_create_enabled=0;
}
LEAVE;
return (element_create_enabled);
} /* node_tool_get_create_enabled */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_get_element_dimension(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 12 April 2007
DESCRIPTION :
Returns the dimension of elements to be created by the <node_tool>.
==============================================================================*/
{
int element_dimension;
ENTER(Node_tool_get_element_dimension);
if (node_tool)
{
element_dimension=node_tool->element_dimension;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_element_dimension. Invalid argument(s)");
element_dimension=0;
}
LEAVE;
return (element_dimension);
} /* node_tool_get_element_dimension */
#endif /* defined (WX_USER_INTERFACE)*/
use ChangeValue(wxString) instead of SetValue(wxString) to avoid callbackwhen setting a value for the dimension text control, wx only
git-svn-id: 4705079bc6b8aadf675e3696f5c015a6aa4916e3@5809 3c1deb5b-d424-0410-962d-aba41a686d42
/*******************************************************************************
FILE : node_tool.c
LAST MODIFIED : 28 October 2004
DESCRIPTION :
Functions for mouse controlled node position and vector editing based on
Scene input.
==============================================================================*/
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is cmgui.
*
* The Initial Developer of the Original Code is
* Auckland Uniservices Ltd, Auckland, New Zealand.
* Portions created by the Initial Developer are Copyright (C) 2005
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
extern "C" {
#include <math.h>
#if defined (MOTIF)
#include <Xm/Protocols.h>
#include <Xm/MwmUtil.h>
#include <Xm/Xm.h>
#include <Xm/ToggleBG.h>
#include "choose/choose_computed_field.h"
#endif /* defined (MOTIF) */
#include "computed_field/computed_field.h"
#include "computed_field/computed_field_composite.h"
#include "computed_field/computed_field_finite_element.h"
#include "computed_field/computed_field_wrappers.h"
#include "general/debug.h"
#include "general/matrix_vector.h"
#include "general/mystring.h"
#include "graphics/element_group_settings.h"
#include "graphics/graphical_element.h"
#include "graphics/graphics_object.h"
#include "help/help_interface.h"
#include "interaction/interaction_graphics.h"
#include "interaction/interaction_volume.h"
#include "interaction/interactive_event.h"
#include "node/node_operations.h"
#include "node/node_tool.h"
#include "finite_element/finite_element.h"
#if defined (MOTIF)
static char node_tool_uidh[] =
#include "node/node_tool.uidh"
;
#include "motif/image_utilities.h"
#include "region/cmiss_region_chooser.h"
#endif /* defined (MOTIF) */
#include "region/cmiss_region.h"
#include "user_interface/gui_dialog_macros.h"
#include "user_interface/message.h"
}
#if defined (WX_USER_INTERFACE)
#include "wx/wx.h"
#include <wx/tglbtn.h>
#include "wx/xrc/xmlres.h"
#include "choose/choose_manager_class.hpp"
#include "graphics/graphics_window_private.hpp"
#include "node/node_tool.xrch"
#include "region/cmiss_region_chooser_wx.hpp"
#endif /* defined (WX_USER_INTERFACE)*/
/*
Module variables
----------------
*/
#if defined (MOTIF)
static int node_tool_hierarchy_open=0;
static MrmHierarchy node_tool_hierarchy;
#endif /* defined (MOTIF) */
static char Interactive_tool_node_type_string[] = "node_tool";
/*
Module types
------------
*/
#if defined (WX_USER_INTERFACE)
class wxNodeTool;
#endif /* defined (WX_USER_INTERFACE) */
struct Node_tool
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Object storing all the parameters for converting scene input messages into
changes in node position and derivatives etc.
==============================================================================*/
{
struct Execute_command *execute_command;
struct MANAGER(Interactive_tool) *interactive_tool_manager;
struct Interactive_tool *interactive_tool;
/* flag indicating that the above manager is actually the data manager */
int use_data;
/* The root region */
struct Cmiss_region *root_region;
/* The region we are working in */
struct Cmiss_region *region;
struct FE_region *fe_region;
/* needed for destroy button */
struct MANAGER(FE_element) *element_manager;
struct FE_node_selection *node_selection;
struct Computed_field_package *computed_field_package;
struct Graphical_material *rubber_band_material;
struct Time_keeper *time_keeper;
struct User_interface *user_interface;
/* user-settable flags */
/* indicates whether node edits can occur with motion_notify events: slower */
int motion_update_enabled;
/* indicates whether existing nodes can be selected */
int select_enabled;
/* indicates whether selected nodes can be edited */
int edit_enabled;
/* indicates whether new fields can be defined at nodes */
int define_enabled;
/* indicates whether new nodes will can be created */
int create_enabled;
/* if create_enabled, controls if create will be streaming, ie. creating
a stream of nodes where the user swipes, rather than just 1 */
int streaming_create_enabled;
/* if create is enabled this option will force the nodes to be created on a surface
rather than between near and far */
int constrain_to_surface;
enum Node_tool_edit_mode edit_mode;
struct Computed_field *coordinate_field, *command_field, *element_xi_field;
/* information about picked nodes the editor knows about */
struct Scene_picked_object *scene_picked_object;
struct FE_node *last_picked_node;
int picked_node_was_unselected;
int motion_detected;
struct GT_element_group *gt_element_group;
struct GT_element_settings *gt_element_settings;
struct Interaction_volume *last_interaction_volume;
struct GT_object *rubber_band;
struct FE_field *FE_coordinate_field;
/* maintain a template node for creating new nodes */
/* the dimension of the elements being created - user settable */
int element_dimension;
/* maintain template element for creating new elements */
struct FE_element *template_element;
/* indicates whether elements are created in response to node selections */
int element_create_enabled;
/* the element being created */
struct FE_element *element;
/* number of nodes that have been set in the element being created */
int number_of_clicked_nodes;
#if defined (MOTIF)
Display *display;
struct Cmiss_region_chooser *cmiss_region_chooser;
Widget coordinate_field_form,coordinate_field_widget,create_button,
constrain_to_surface_button,define_button,edit_button,
motion_update_button,node_group_form,node_group_widget,select_button,
streaming_create_button,command_field_button,command_field_form,
command_field_widget;
Widget widget,window_shell;
#else /* defined (MOTIF) */
/* without cmiss_region_chooser need somewhere to store the region path */
char *current_region_path;
#endif /* defined (MOTIF) */
#if defined (WX_USER_INTERFACE)
wxNodeTool *wx_node_tool;
struct MANAGER(Computed_field) *computed_field_manager;
wxPoint tool_position;
#endif /* defined (WX_USER_INTERFACE) */
}; /* struct Node_tool */
struct FE_node_edit_information
/*******************************************************************************
LAST MODIFIED : 19 February 2008
DESCRIPTION :
Describes how to move a node in space. The node will move on the plane normal
to the viewing direction a distance proportional to the two starting and
finishing points on the near and far plane. The exact amount is in proportion
to its position between these two planes.
==============================================================================*/
{
/* the actual coordinate change calculated from the drag at the last picked
node */
double delta1,delta2,delta3;
/* the current value of the time being used */
FE_value time;
/* the gesture indicated by the mouse is given by initial and final
interaction volumes */
struct Interaction_volume *final_interaction_volume,
*initial_interaction_volume;
/* the field to translate */
struct Computed_field *coordinate_field;
/* The same field wrapped to get RC coordinates */
struct Computed_field *rc_coordinate_field;
/* following required for EDIT_VECTOR only */
struct Computed_field *orientation_scale_field,
*wrapper_orientation_scale_field, *variable_scale_field;
Triple glyph_centre, glyph_scale_factors, glyph_size;
/* editing nodes in this region */
struct FE_region *fe_region;
/* information for undoing scene object transformations - only needs to be
done if transformation_required is set */
int transformation_required,LU_indx[4];
double transformation_matrix[16],LU_transformation_matrix[16];
/* The last_picked node is used to calculate the delta change and so when
the whole active group is looped over this node is ignored */
struct FE_node *last_picked_node;
/* Fields that allow constrain_to_surface to work correctly,
only the last picked node will be updated as this is the only one
we know the element for */
int constrain_to_surface;
struct FE_element *nearest_element;
struct Computed_field *nearest_element_coordinate_field;
struct Computed_field *element_xi_field;
}; /* struct FE_node_edit_information */
struct Node_tool_element_constraint_function_data
{
struct FE_element *element, *found_element;
FE_value xi[MAXIMUM_ELEMENT_XI_DIMENSIONS];
struct Computed_field *coordinate_field;
}; /* struct Node_tool_element_constraint_function_data */
/*
Module functions
----------------
*/
#if defined (MOTIF)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,coordinate_field_form)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,create_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,constrain_to_surface_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,define_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,edit_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,motion_update_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,node_group_form)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,select_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,streaming_create_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,command_field_button)
DECLARE_DIALOG_IDENTIFY_FUNCTION(node_tool,Node_tool,command_field_form)
#endif /* defined (MOTIF) */
/* Prototype */
#if defined (WX_USER_INTERFACE)
static int Node_tool_end_element_creation(
struct Node_tool *node_tool);
#endif /*defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_create_enabled(struct Node_tool *node_tool,
int create_enabled);
#endif /*defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_dimension(
struct Node_tool *node_tool,int element_dimension);
#endif /*defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
static int Node_tool_refresh_element_dimension_text(
struct Node_tool *node_tool);
#endif /*defined (WX_USER_INTERFACE)*/
static int Node_tool_define_field_at_node(struct Node_tool *node_tool,
struct FE_node *node)
/*******************************************************************************
LAST MODIFIED : 16 October 2001
DESCRIPTION :
Defines the appropriate FE_field upon which the <coordinate_field> depends in
<node>. The field is defined with no versions or derivatives.
==============================================================================*/
{
int return_code;
struct FE_field *fe_field;
struct FE_node_field_creator *node_field_creator;
struct LIST(FE_field) *fe_field_list;
ENTER(Node_tool_define_field_at_node);
if (node_tool && node)
{
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list))&&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)) && (3 >= get_FE_field_number_of_components(
fe_field)) && (FE_VALUE_VALUE == get_FE_field_value_type(fe_field)))
{
if (node_field_creator = CREATE(FE_node_field_creator)(
/*number_of_components*/3))
{
if (define_FE_field_at_node(node,fe_field,
(struct FE_time_sequence *)NULL,
node_field_creator))
{
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Failed");
return_code=0;
}
DESTROY(FE_node_field_creator)(&node_field_creator);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Unable to make creator.");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Invalid field");
return_code=0;
}
DESTROY(LIST(FE_field))(&fe_field_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. No field to define");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_define_field_at_node */
static int FE_node_define_and_set_element_xi(struct FE_node *node,
struct Computed_field *element_xi_field,
struct FE_element *element, FE_value *xi)
/*******************************************************************************
LAST MODIFIED : 19 February 2008
DESCRIPTION :
Defines element_xi_field at node if not already defined. Sets value.
==============================================================================*/
{
int return_code;
struct FE_field *fe_field;
struct FE_node_field_creator *node_field_creator;
ENTER(FE_node_define_and_set_element_xi);
return_code = 0;
if (node && element_xi_field && element && xi)
{
fe_field = (struct FE_field *)NULL;
if (Computed_field_get_type_finite_element(element_xi_field, &fe_field))
{
if (!FE_field_is_defined_at_node(fe_field,node))
{
if (node_field_creator =
CREATE(FE_node_field_creator)(/*number_of_components*/1))
{
define_FE_field_at_node(node, fe_field,
(struct FE_time_sequence *)NULL, node_field_creator);
DESTROY(FE_node_field_creator)(&node_field_creator);
}
}
return_code = set_FE_nodal_element_xi_value(node,fe_field,/*component_number*/0,
/*version*/0,FE_NODAL_VALUE,element,xi);
}
if (!return_code)
{
display_message(ERROR_MESSAGE,
"FE_node_define_and_set_element_xi. Failed");
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_define_and_set_element_xi. Invalid argument(s)");
}
LEAVE;
return (return_code);
} /* FE_node_define_and_set_element_xi */
static int model_to_world_coordinates(FE_value coordinates[3],
double *transformation_matrix)
/*******************************************************************************
LAST MODIFIED : 23 July 1999
DESCRIPTION :
Makes a homogoneous coordinate [x,y,z,1] out of <coordinates> and premultiplies
it by the 16 value 4x4 <transformation_matrix> to give [x',y',z',h']. If h' is
non-zero the <coordinates> are modified to [x'/h',y'/h',z'/h'], otherwise an
error is reported.
==============================================================================*/
{
double h,model_coordinates[4],world_coordinates[4];
int return_code;
ENTER(model_to_world_coordinates);
if (coordinates&&transformation_matrix)
{
model_coordinates[0]=(double)coordinates[0];
model_coordinates[1]=(double)coordinates[1];
model_coordinates[2]=(double)coordinates[2];
model_coordinates[3]=1.0;
if (multiply_matrix(4,4,1,transformation_matrix,
model_coordinates,world_coordinates)&&
(0.0 != (h=world_coordinates[3])))
{
coordinates[0]=(FE_value)(world_coordinates[0] / h);
coordinates[1]=(FE_value)(world_coordinates[1] / h);
coordinates[2]=(FE_value)(world_coordinates[2] / h);
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"model_to_world_coordinates. Invalid transformation");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"model_to_world_coordinates. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* model_to_world_coordinates */
static int world_to_model_coordinates(FE_value coordinates[3],
double *LU_transformation_matrix,int *LU_indx)
/*******************************************************************************
LAST MODIFIED : 23 July 1999
DESCRIPTION :
Makes a homogoneous coordinate [x',y',z',1] out of <coordinates> and solves for
the homogeneous model_coordinates [x,y,z,h] using the already-decomposed
16 value 4x4 <LU_transformation_matrix> and associated 4 value <LU_indx> vector.
If h is non-zero the <coordinates> are modified to [x/h,y/h,z/h], otherwise an
error is reported.
==============================================================================*/
{
double h,model_coordinates[4];
int return_code;
ENTER(world_to_model_coordinates);
if (coordinates&&LU_transformation_matrix)
{
model_coordinates[0]=(double)coordinates[0];
model_coordinates[1]=(double)coordinates[1];
model_coordinates[2]=(double)coordinates[2];
model_coordinates[3]=1.0;
if (LU_backsubstitute(4,LU_transformation_matrix,LU_indx,
model_coordinates)&&(0.0 != (h=model_coordinates[3],/*singular_tolerance*/1.0e-12)))
{
coordinates[0]=(FE_value)(model_coordinates[0] / h);
coordinates[1]=(FE_value)(model_coordinates[1] / h);
coordinates[2]=(FE_value)(model_coordinates[2] / h);
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"world_to_model_coordinates. Invalid transformation");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"world_to_model_coordinates. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* world_to_model_coordinates */
static int Node_tool_element_constraint_function(FE_value *point,
void *void_data)
/*******************************************************************************
LAST MODIFIED : 14 February 2008
DESCRIPTION :
==============================================================================*/
{
int return_code;
struct Node_tool_element_constraint_function_data *data;
ENTER(Node_tool_element_constraint_function_data);
if (point && (data = (struct Node_tool_element_constraint_function_data *)void_data))
{
data->found_element = data->element;
return_code = Computed_field_find_element_xi(data->coordinate_field,
point, /*number_of_values*/3, &(data->found_element),
data->xi, /*element_dimension*/2,
(struct Cmiss_region *)NULL, /*propagate_field*/0, /*find_nearest_location*/1);
Computed_field_evaluate_in_element(data->coordinate_field,
data->found_element, data->xi, /*time*/0.0, (struct FE_element *)NULL,
point, (FE_value *)NULL);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_element_constraint_function. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_element_constraint_function */
static int FE_node_calculate_delta_position(struct FE_node *node,
void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 27 April 2000
DESCRIPTION :
Calculates the delta change in the coordinates due to the ray supplied in the
<edit_info>. This change is set inside the <edit_info> and this can then be
applied to multiple nodes.
==============================================================================*/
{
double model_coordinates[3],normalised_coordinates[3],placement_coordinates[3];
FE_value coordinates[3], initial_coordinates[3], final_coordinates[3];
int i, return_code;
struct FE_node_edit_information *edit_info;
struct Node_tool_element_constraint_function_data constraint_data;
ENTER(FE_node_calculate_delta_position);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->rc_coordinate_field&&
(3>=Computed_field_get_number_of_components(
edit_info->rc_coordinate_field)))
{
return_code=1;
/* clear coordinates in case less than 3 dimensions */
coordinates[0]=0.0;
coordinates[1]=0.0;
coordinates[2]=0.0;
if (Computed_field_evaluate_at_node(edit_info->rc_coordinate_field,
node,edit_info->time,coordinates))
{
initial_coordinates[0] = coordinates[0];
initial_coordinates[1] = coordinates[1];
initial_coordinates[2] = coordinates[2];
if (edit_info->transformation_required)
{
return_code=model_to_world_coordinates(coordinates,
edit_info->transformation_matrix);
}
if (return_code)
{
if (edit_info->constrain_to_surface && edit_info->nearest_element &&
edit_info->nearest_element_coordinate_field)
{
constraint_data.element = edit_info->nearest_element;
constraint_data.found_element = edit_info->nearest_element;
constraint_data.coordinate_field = edit_info->nearest_element_coordinate_field;
for (i = 0; i < MAXIMUM_ELEMENT_XI_DIMENSIONS; i++)
{
constraint_data.xi[i] = 0.5;
}
Interaction_volume_get_placement_point(edit_info->final_interaction_volume,
placement_coordinates, Node_tool_element_constraint_function,
&constraint_data);
coordinates[0] = placement_coordinates[0];
coordinates[1] = placement_coordinates[1];
coordinates[2] = placement_coordinates[2];
}
else
{
/* convert initial model coordinates into normalised coordinates in the
space of the initial_interaction_volume, and back into model
coordinates in the space of the final_interaction_volume to get
translation of node */
model_coordinates[0]=(double)coordinates[0];
model_coordinates[1]=(double)coordinates[1];
model_coordinates[2]=(double)coordinates[2];
return_code=Interaction_volume_model_to_normalised_coordinates(
edit_info->initial_interaction_volume,model_coordinates,
normalised_coordinates)&&
Interaction_volume_normalised_to_model_coordinates(
edit_info->final_interaction_volume,normalised_coordinates,
model_coordinates);
coordinates[0]=(FE_value)model_coordinates[0];
coordinates[1]=(FE_value)model_coordinates[1];
coordinates[2]=(FE_value)model_coordinates[2];
}
}
if (return_code&&edit_info->transformation_required)
{
return_code=world_to_model_coordinates(coordinates,
edit_info->LU_transformation_matrix,edit_info->LU_indx);
}
if (return_code)
{
edit_info->last_picked_node = node;
if (edit_info->coordinate_field != edit_info->rc_coordinate_field)
{
/* get delta of coordinate_field from change of rc_coordinate_field */
return_code=Computed_field_evaluate_at_node(
edit_info->coordinate_field,node,edit_info->time,
initial_coordinates)&&
Computed_field_set_values_at_node(
edit_info->rc_coordinate_field,node,edit_info->time,
coordinates)&&
Computed_field_evaluate_at_node(edit_info->coordinate_field,
node,edit_info->time,final_coordinates);
edit_info->delta1 = final_coordinates[0] - initial_coordinates[0];
edit_info->delta2 = final_coordinates[1] - initial_coordinates[1];
edit_info->delta3 = final_coordinates[2] - initial_coordinates[2];
}
else
{
edit_info->delta1 = coordinates[0] - initial_coordinates[0];
edit_info->delta2 = coordinates[1] - initial_coordinates[1];
edit_info->delta3 = coordinates[2] - initial_coordinates[2];
return_code=Computed_field_set_values_at_node(
edit_info->rc_coordinate_field,node,edit_info->time,
coordinates);
}
/* may be some application for not editing element_xi field value */
if (return_code && edit_info->nearest_element &&
constraint_data.found_element && edit_info->element_xi_field)
{
return_code = FE_node_define_and_set_element_xi(node,
edit_info->element_xi_field, constraint_data.found_element,
constraint_data.xi);
}
}
}
else
{
return_code=0;
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->rc_coordinate_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_position. Failed");
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_position. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_calculate_delta_position */
static int FE_node_edit_position(struct FE_node *node,void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 15 September 2000
DESCRIPTION :
Translates the <rc_coordinate_field> of <node> according to the delta change
stored in the <edit_info>.
==============================================================================*/
{
FE_value coordinates[3];
int return_code;
struct FE_node_edit_information *edit_info;
ENTER(FE_node_edit_position);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->rc_coordinate_field&&
(3>=Computed_field_get_number_of_components(
edit_info->rc_coordinate_field)))
{
return_code=1;
/* the last_picked_node was edited in FE_node_calculate_delta_position.
Also, don't edit unless in node_group, if supplied */
if ((node != edit_info->last_picked_node)&&(
FE_region_contains_FE_node(edit_info->fe_region, node)))
{
/* clear coordinates in case less than 3 dimensions */
coordinates[0]=0.0;
coordinates[1]=0.0;
coordinates[2]=0.0;
/* If the field we are changing isn't defined at this node then we
don't complain and just do nothing */
if (Computed_field_is_defined_at_node(edit_info->coordinate_field,node)&&
Computed_field_evaluate_at_node(edit_info->coordinate_field,
node,edit_info->time,coordinates))
{
if (return_code)
{
coordinates[0] += edit_info->delta1;
coordinates[1] += edit_info->delta2;
coordinates[2] += edit_info->delta3;
if (!Computed_field_set_values_at_node(edit_info->coordinate_field,
node,edit_info->time, coordinates))
{
return_code=0;
}
}
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->coordinate_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,"FE_node_edit_position. Failed");
}
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_edit_position. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_edit_position */
static int FE_node_calculate_delta_vector(struct FE_node *node,
void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 20 November 2000
DESCRIPTION :
Moves the end of the vector to exactly under the mouse, in the plane normal to the view direction at its current depth. Hence, this function should only be
called for a single node.
Note that you must supply an orientation_scale field, while glyph_size[0] and
glyph_centre[0] must be 0.0, and glyph_scale_factors[0] must be non-zero.
NOTE: currently does not tolerate having a variable_scale_field.
==============================================================================*/
{
double model_coordinates[3],normalised_coordinates[3];
FE_value a[3],b[3],c[3],coordinates[3],end_coordinates[3],old_coordinates[3],
orientation_scale[9],scale_factor;
int number_of_orientation_scale_components,return_code;
struct FE_node_edit_information *edit_info;
Triple size;
ENTER(FE_node_calculate_delta_vector);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->rc_coordinate_field&&
(3>=Computed_field_get_number_of_components(
edit_info->rc_coordinate_field))&&
edit_info->wrapper_orientation_scale_field&&
(0<(number_of_orientation_scale_components=
Computed_field_get_number_of_components(
edit_info->wrapper_orientation_scale_field)))&&
(9>=number_of_orientation_scale_components)&&
(0.0 == edit_info->glyph_centre[0])&&
(0.0 == edit_info->glyph_size[0])&&
(0.0 != (scale_factor=edit_info->glyph_scale_factors[0])) &&
((struct Computed_field *)NULL == edit_info->variable_scale_field))
{
return_code=1;
/* clear coordinates in case less than 3 dimensions */
coordinates[0]=0.0;
coordinates[1]=0.0;
coordinates[2]=0.0;
if (Computed_field_evaluate_at_node(
edit_info->wrapper_orientation_scale_field,node,edit_info->time,
orientation_scale)&&
Computed_field_evaluate_at_node(edit_info->rc_coordinate_field,
node,edit_info->time,coordinates)&&
make_glyph_orientation_scale_axes(number_of_orientation_scale_components,
orientation_scale, a, b, c, size))
{
/* save old coordinates since will not change when converted back to
model coordinates */
old_coordinates[0]=coordinates[0];
old_coordinates[1]=coordinates[1];
old_coordinates[2]=coordinates[2];
end_coordinates[0]=coordinates[0]+size[0]*scale_factor*a[0];
end_coordinates[1]=coordinates[1]+size[0]*scale_factor*a[1];
end_coordinates[2]=coordinates[2]+size[0]*scale_factor*a[2];
if (edit_info->transformation_required)
{
return_code=model_to_world_coordinates(coordinates,
edit_info->transformation_matrix)&&
model_to_world_coordinates(end_coordinates,
edit_info->transformation_matrix);
}
if (return_code)
{
/* convert end_coordinates into normalised coordinates in the
space of the initial_interaction_volume, and back into model
coordinates centred in the space of the final_interaction_volume to
get new end point */
model_coordinates[0]=(double)end_coordinates[0];
model_coordinates[1]=(double)end_coordinates[1];
model_coordinates[2]=(double)end_coordinates[2];
return_code=Interaction_volume_model_to_normalised_coordinates(
edit_info->initial_interaction_volume,model_coordinates,
normalised_coordinates)&&
Interaction_volume_centred_normalised_to_model_coordinates(
edit_info->final_interaction_volume,normalised_coordinates,
model_coordinates);
end_coordinates[0]=(FE_value)model_coordinates[0];
end_coordinates[1]=(FE_value)model_coordinates[1];
end_coordinates[2]=(FE_value)model_coordinates[2];
}
if (edit_info->transformation_required)
{
return_code=world_to_model_coordinates(end_coordinates,
edit_info->LU_transformation_matrix,edit_info->LU_indx);
}
if (return_code)
{
/* note use of old_coordinates in model space */
a[0]=(end_coordinates[0]-old_coordinates[0])/scale_factor;
a[1]=(end_coordinates[1]-old_coordinates[1])/scale_factor;
a[2]=(end_coordinates[2]-old_coordinates[2])/scale_factor;
switch (number_of_orientation_scale_components)
{
case 1:
{
/* scalar */
edit_info->delta1=orientation_scale[0]=a[0];
} break;
case 2:
case 4:
{
/* 1 or 2 2-D vectors */
edit_info->delta1=orientation_scale[0]=a[0];
edit_info->delta2=orientation_scale[1]=a[1];
} break;
case 3:
case 6:
case 9:
{
/* 1,2 or 3, 3-D vectors */
edit_info->delta1=orientation_scale[0]=a[0];
edit_info->delta2=orientation_scale[1]=a[1];
edit_info->delta3=orientation_scale[2]=a[2];
} break;
default:
{
display_message(ERROR_MESSAGE,"FE_node_calculate_delta_vector. "
"Invalid number of orientation scale components");
return_code=0;
} break;
}
}
if (return_code)
{
if (!Computed_field_set_values_at_node(
edit_info->wrapper_orientation_scale_field,node,edit_info->time,
orientation_scale))
{
return_code=0;
}
if (edit_info->orientation_scale_field !=
edit_info->wrapper_orientation_scale_field)
{
/* get delta values from the orientation_scale_field */
if (Computed_field_evaluate_at_node(
edit_info->orientation_scale_field,node,
edit_info->time,orientation_scale))
{
number_of_orientation_scale_components=
Computed_field_get_number_of_components(
edit_info->orientation_scale_field);
switch (number_of_orientation_scale_components)
{
case 1:
{
/* scalar */
edit_info->delta1=orientation_scale[0];
} break;
case 2:
case 4:
{
/* 1 or 2 2-D vectors */
edit_info->delta1=orientation_scale[0];
edit_info->delta2=orientation_scale[1];
} break;
case 3:
case 6:
case 9:
{
/* 1,2 or 3, 3-D vectors */
edit_info->delta1=orientation_scale[0];
edit_info->delta2=orientation_scale[1];
edit_info->delta3=orientation_scale[2];
} break;
default:
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_vector. "
"Invalid number of orientation scale components");
return_code=0;
} break;
}
}
else
{
return_code=0;
}
}
}
}
else
{
return_code=0;
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->rc_coordinate_field);
Computed_field_clear_cache(edit_info->wrapper_orientation_scale_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,"FE_node_calculate_delta_vector. Failed");
}
}
else
{
if ((0.0 != edit_info->glyph_centre[0]) ||
(0.0 != edit_info->glyph_size[0]) ||
(0.0 == (scale_factor=edit_info->glyph_scale_factors[0])))
{
if (0.0 != edit_info->glyph_centre[0])
{
display_message(ERROR_MESSAGE,
"To edit orientation vectors your main direction glyph centre must be zero.");
}
if (0.0 != edit_info->glyph_size[0])
{
display_message(ERROR_MESSAGE,
"To edit orientation vectors your main direction base glyph size must be zero.");
}
if (0.0 == (scale_factor=edit_info->glyph_scale_factors[0]))
{
display_message(ERROR_MESSAGE,
"To edit orientation vectors your main direction scale factor must not be zero.");
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_calculate_delta_vector. Invalid argument(s)");
}
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_calculate_delta_vector */
static int FE_node_edit_vector(struct FE_node *node,void *edit_info_void)
/*******************************************************************************
LAST MODIFIED : 22 March 2000
DESCRIPTION :
Translates the <rc_coordinate_field> of <node> according to the delta change
stored in the <edit_info>.
==============================================================================*/
{
FE_value orientation_scale[9];
int number_of_orientation_scale_components,return_code;
struct FE_node_edit_information *edit_info;
ENTER(FE_node_edit_vector);
if (node&&(edit_info=(struct FE_node_edit_information *)edit_info_void)&&
edit_info->fe_region&&edit_info->orientation_scale_field&&
(0<(number_of_orientation_scale_components=
Computed_field_get_number_of_components(
edit_info->orientation_scale_field)))&&
(9>=number_of_orientation_scale_components))
{
return_code=1;
/* the last_picked_node was edited in FE_node_calculate_delta_vector. */
if ((node != edit_info->last_picked_node)&&(
FE_region_contains_FE_node(edit_info->fe_region, node)))
{
if (Computed_field_evaluate_at_node(
edit_info->orientation_scale_field,node,edit_info->time,
orientation_scale))
{
switch (number_of_orientation_scale_components)
{
case 1:
{
/* scalar */
orientation_scale[0]=edit_info->delta1;
} break;
case 2:
case 4:
{
/* 1 or 2 2-D vectors */
orientation_scale[0]=edit_info->delta1;
orientation_scale[1]=edit_info->delta2;
} break;
case 3:
case 6:
case 9:
{
/* 1,2 or 3, 3-D vectors */
orientation_scale[0]=edit_info->delta1;
orientation_scale[1]=edit_info->delta2;
orientation_scale[2]=edit_info->delta3;
} break;
default:
{
display_message(ERROR_MESSAGE,"FE_node_edit_vector. "
"Invalid number of orientation scale components");
return_code=0;
} break;
}
if (return_code)
{
if (!Computed_field_set_values_at_node(
edit_info->orientation_scale_field,node,edit_info->time,
orientation_scale))
{
return_code=0;
}
}
}
else
{
return_code=0;
}
/* always clear caches of evaluated fields */
Computed_field_clear_cache(edit_info->orientation_scale_field);
if (!return_code)
{
display_message(ERROR_MESSAGE,"FE_node_edit_vector. Failed");
}
}
}
else
{
display_message(ERROR_MESSAGE,
"FE_node_edit_vector. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* FE_node_edit_vector */
static int Node_tool_define_field_at_node_from_picked_coordinates(
struct Node_tool *node_tool,struct FE_node *node)
/*******************************************************************************
LAST MODIFIED : 29 September 2000
DESCRIPTION :
Defines the coordinate_field at the node using the position of the picked
object's coordinate field.
==============================================================================*/
{
FE_value coordinates[3], time;
int return_code;
struct Computed_field *coordinate_field, *picked_coordinate_field,
*rc_coordinate_field, *rc_picked_coordinate_field;
ENTER(Node_tool_define_field_at_node_from_picked_coordinates);
if (node_tool&&node)
{
coordinate_field=node_tool->coordinate_field;
if (node_tool->time_keeper)
{
time = Time_keeper_get_time(node_tool->time_keeper);
}
else
{
time = 0;
}
if (rc_coordinate_field=
Computed_field_begin_wrap_coordinate_field(coordinate_field))
{
if (!(picked_coordinate_field = GT_element_settings_get_coordinate_field(
node_tool->gt_element_settings)))
{
picked_coordinate_field = GT_element_group_get_default_coordinate_field(
node_tool->gt_element_group);
}
rc_picked_coordinate_field = Computed_field_begin_wrap_coordinate_field(
picked_coordinate_field);
if (Computed_field_evaluate_at_node(rc_picked_coordinate_field,
node,time,coordinates))
{
if (Node_tool_define_field_at_node(node_tool,node)&&
Computed_field_set_values_at_node(rc_coordinate_field,
node,time,coordinates))
{
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. Failed");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. "
"Unable to evaluate picked position.");
return_code=0;
}
Computed_field_clear_cache(rc_picked_coordinate_field);
Computed_field_end_wrap(&rc_picked_coordinate_field);
Computed_field_clear_cache(rc_coordinate_field);
Computed_field_end_wrap(&rc_coordinate_field);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. "
"Could not wrap coordinate field");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_field_at_node_from_picked_coordinates. "
"Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_define_field_at_node_from_picked_coordinates */
static struct FE_node *Node_tool_create_node_at_interaction_volume(
struct Node_tool *node_tool,struct Scene *scene,
struct Interaction_volume *interaction_volume,
struct FE_element *nearest_element, struct Computed_field *element_coordinate_field)
/*******************************************************************************
LAST MODIFIED : 14 February 2008
DESCRIPTION :
Returns a new node in the position indicated by <interaction_volume>, in the
<scene> if suppled. If any of the remaining address arguments
are not NULL, they are filled with the appropriate information pertaining to
the new node.
If <nearest_element> and <coordinate_field> are supplied then
the interaction volume will be supplied a constraint function which will
try to enforce that the node is created on that element.
==============================================================================*/
{
double d,LU_transformation_matrix[16],node_coordinates[3];
enum GT_element_settings_type gt_element_settings_type;
FE_value coordinates[3];
int i,LU_indx[4],node_number,transformation_required;
struct Computed_field *rc_coordinate_field,*node_tool_coordinate_field;
struct FE_node *merged_node, *node;
struct GT_element_group *gt_element_group;
struct GT_element_settings *gt_element_settings;
struct Node_tool_element_constraint_function_data constraint_data;
struct Scene_object *scene_object;
LIST_CONDITIONAL_FUNCTION(Scene_object) *scene_object_conditional_function;
struct Scene_picked_object *scene_picked_object;
ENTER(Node_tool_create_node_at_interaction_volume);
merged_node = (struct FE_node *)NULL;
scene_picked_object=(struct Scene_picked_object *)NULL;
gt_element_group=(struct GT_element_group *)NULL;
gt_element_settings=(struct GT_element_settings *)NULL;
if (!node_tool || !interaction_volume)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. Invalid argument(s)");
}
else
{
if (!node_tool->coordinate_field)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. No coordinate field to define");
}
else if (!node_tool->fe_region)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. No region chosen for new node");
}
else
{
node_tool_coordinate_field=node_tool->coordinate_field;
if (node_tool->use_data)
{
scene_object_conditional_function=Scene_object_has_data_Cmiss_region;
gt_element_settings_type=GT_ELEMENT_SETTINGS_DATA_POINTS;
}
else
{
scene_object_conditional_function=Scene_object_has_Cmiss_region;
gt_element_settings_type=GT_ELEMENT_SETTINGS_NODE_POINTS;
}
if (scene&&(scene_object=first_Scene_object_in_Scene_that(scene,
scene_object_conditional_function,(void *)node_tool->region)))
{
gt_element_group=Scene_object_get_graphical_element_group(scene_object);
gt_element_settings=first_settings_in_GT_element_group_that(
gt_element_group,GT_element_settings_type_matches,
(void *)gt_element_settings_type);
/* return a scene_object with the correct transformation */
if (scene_picked_object=CREATE(Scene_picked_object)(/*hit_no*/0))
{
Scene_picked_object_add_Scene_object(scene_picked_object,
scene_object);
REACCESS(Scene_picked_object)(&(node_tool->scene_picked_object),
scene_picked_object);
}
}
else
{
scene_picked_object=(struct Scene_picked_object *)NULL;
}
if (rc_coordinate_field=
Computed_field_begin_wrap_coordinate_field(node_tool_coordinate_field))
{
node_number = FE_region_get_next_FE_node_identifier(
node_tool->fe_region, /*start*/1);
/* get new node coordinates from interaction_volume */
if (nearest_element && element_coordinate_field)
{
constraint_data.element = nearest_element;
constraint_data.found_element = nearest_element;
constraint_data.coordinate_field = element_coordinate_field;
for (i = 0; i < MAXIMUM_ELEMENT_XI_DIMENSIONS; i++)
{
constraint_data.xi[i] = 0.5;
}
Interaction_volume_get_placement_point(interaction_volume,
node_coordinates, Node_tool_element_constraint_function,
&constraint_data);
}
else
{
Interaction_volume_get_placement_point(interaction_volume,
node_coordinates, (Interation_volume_constraint_function)NULL,
(void *)NULL);
}
for (i=0;i<3;i++)
{
coordinates[i]=(FE_value)node_coordinates[i];
}
if (scene_picked_object&&
Scene_picked_object_get_total_transformation_matrix(
node_tool->scene_picked_object,&transformation_required,
LU_transformation_matrix)&&transformation_required&&
LU_decompose(4,LU_transformation_matrix,LU_indx,&d,/*singular_tolerance*/1.0e-12))
{
world_to_model_coordinates(coordinates,
LU_transformation_matrix,LU_indx);
}
node = CREATE(FE_node)(node_number, node_tool->fe_region, /*template*/(struct FE_node *)NULL);
if (!node)
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. Could not create node");
}
else
{
ACCESS(FE_node)(node);
if (!Node_tool_define_field_at_node(node_tool,node) ||
!Computed_field_set_values_at_node(rc_coordinate_field, node,
/*time*/0, coordinates) ||
(nearest_element && constraint_data.found_element && node_tool->element_xi_field &&
!FE_node_define_and_set_element_xi(node, node_tool->element_xi_field,
constraint_data.found_element, constraint_data.xi)) ||
(NULL == (merged_node =
FE_region_merge_FE_node(node_tool->fe_region, node))))
{
display_message(ERROR_MESSAGE,
"Node_tool_create_node_at_interaction_volume. Could not define and set fields");
}
DEACCESS(FE_node)(&node);
}
Computed_field_clear_cache(rc_coordinate_field);
Computed_field_end_wrap(&rc_coordinate_field);
}
}
}
if (node_tool)
{
/* only need following if editing; in which case need all of them */
if ((!merged_node) || (!scene_picked_object) || (!gt_element_group) ||
(!gt_element_settings))
{
scene_picked_object=(struct Scene_picked_object *)NULL;
gt_element_group=(struct GT_element_group *)NULL;
gt_element_settings=(struct GT_element_settings *)NULL;
}
/* make sure node_tool point at following as found out above */
REACCESS(Scene_picked_object)(&(node_tool->scene_picked_object),
scene_picked_object);
REACCESS(GT_element_group)(&(node_tool->gt_element_group),
gt_element_group);
REACCESS(GT_element_settings)(&(node_tool->gt_element_settings),
gt_element_settings);
}
LEAVE;
return (merged_node);
} /* Node_tool_create_node_at_interaction_volume */
static int Node_tool_set_Cmiss_region(struct Node_tool *node_tool,
struct Cmiss_region *region)
/*******************************************************************************
LAST MODIFIED : 20 March 2003
DESCRIPTION :
Sets the <region> used by <node_tool>.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_Cmiss_region);
if (node_tool)
{
return_code=1;
if (region != node_tool->region)
{
node_tool->region = region;
if (region)
{
node_tool->fe_region = Cmiss_region_get_FE_region(region);
}
else
{
node_tool->fe_region = (struct FE_region *)NULL;
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_Cmiss_region. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_Cmiss_region */
#if defined (MOTIF)
static void Node_tool_close_CB(Widget widget,void *node_tool_void,
void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback when "close" is selected from the window menu, or it is double
clicked. How this is made to occur is as follows. The dialog has its
XmNdeleteResponse == XmDO_NOTHING, and a window manager protocol callback for
WM_DELETE_WINDOW has been set up with XmAddWMProtocolCallback to call this
function in response to the close command. See CREATE for more details.
Function pops down dialog as a response,
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_close_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
XtPopdown(node_tool->window_shell);
}
else
{
display_message(ERROR_MESSAGE,"Node_tool_close_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_close_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_create_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether nodes are created in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_create_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_create_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_create_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_create_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_define_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 11 September 2000
DESCRIPTION :
Callback from toggle button controlling whether fields are defined at nodes in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_define_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_define_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_define_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_define_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_edit_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether nodes are edited in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_edit_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_edit_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_edit_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_edit_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_motion_update_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether editing motions are updated
during the edit - if off then updates only once at the end.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_motion_update_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_motion_update_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_motion_update_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_motion_update_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_select_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Callback from toggle button controlling whether nodes are selected in
response to interactive events.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_select_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_select_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_select_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_select_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_streaming_create_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 14 May 2001
DESCRIPTION :
Callback from toggle button controlling whether nodes are created continuously,
ie. streaming in response to interactive events = user drags.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_streaming_create_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_streaming_create_enabled(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_streaming_create_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_streaming_create_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_constrain_to_surface_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 18 April 2005
DESCRIPTION :
Callback from toggle button controlling whether nodes are created on surface
elements or just halfway between near and far.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_constrain_to_surface_button_CB);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_constrain_to_surface(node_tool,
XmToggleButtonGadgetGetState(widget));
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_constrain_to_surface_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_constrain_to_surface_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_command_field_button_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Callback from toggle button enabling a command_field to be selected.
==============================================================================*/
{
struct Computed_field *command_field;
struct Node_tool *node_tool;
ENTER(Node_tool_command_field_button_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (Node_tool_get_command_field(node_tool))
{
Node_tool_set_command_field(node_tool, (struct Computed_field *)NULL);
}
else
{
/* get label field from widget */
command_field = CHOOSE_OBJECT_GET_OBJECT(Computed_field)(
node_tool->command_field_widget);
if (command_field)
{
Node_tool_set_command_field(node_tool, command_field);
}
else
{
XtVaSetValues(node_tool->command_field_button, XmNset, False, NULL);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_command_field_button_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_command_field_button_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_update_command_field(Widget widget,
void *node_tool_void, void *command_field_void)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Callback for change of command_field.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_update_command_field);
USE_PARAMETER(widget);
if (node_tool = (struct Node_tool *)node_tool_void)
{
/* skip messages from chooser if it is grayed out */
if (XtIsSensitive(node_tool->command_field_widget))
{
Node_tool_set_command_field(node_tool,
(struct Computed_field *)command_field_void);
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_update_command_field. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_update_command_field */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_update_region(Widget widget,
void *node_tool_void,void *region_void)
/*******************************************************************************
LAST MODIFIED : 23 January 2003
DESCRIPTION :
Callback for change of region that we are working in.
==============================================================================*/
{
struct Cmiss_region *region;
struct Node_tool *node_tool;
ENTER(Node_tool_update_region);
USE_PARAMETER(widget);
if (node_tool=(struct Node_tool *)node_tool_void)
{
region = (struct Cmiss_region *)region_void;
Node_tool_set_Cmiss_region(node_tool, region);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_update_region. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_update_region */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_update_coordinate_field(Widget widget,
void *node_tool_void,void *coordinate_field_void)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Callback for change of coordinate_field.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_update_coordinate_field);
USE_PARAMETER(widget);
if (node_tool=(struct Node_tool *)node_tool_void)
{
Node_tool_set_coordinate_field(node_tool,
(struct Computed_field *)coordinate_field_void);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_update_coordinate_field. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_update_coordinate_field */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_destroy_selected_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 28 April 2003
DESCRIPTION :
Attempts to destroy all the nodes currently in the global selection.
==============================================================================*/
{
struct LIST(FE_node) *destroy_node_list;
struct Node_tool *node_tool;
struct FE_region *master_fe_region;
ENTER(Node_tool_destroy_selected_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (destroy_node_list=CREATE(LIST(FE_node))())
{
COPY_LIST(FE_node)(destroy_node_list,
FE_node_selection_get_node_list(node_tool->node_selection));
/* nodes destroyed only if removed from ultimate master FE_region */
if (FE_region_get_ultimate_master_FE_region(node_tool->fe_region,
&master_fe_region))
{
FE_region_begin_change(master_fe_region);
FE_region_remove_FE_node_list(master_fe_region, destroy_node_list);
FE_region_end_change(master_fe_region);
}
DESTROY(LIST(FE_node))(&destroy_node_list);
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_destroy_selected_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_destroy_selected_CB */
#endif /* defined (MOTIF) */
#if defined (MOTIF)
static void Node_tool_undefine_selected_CB(Widget widget,
void *node_tool_void,void *call_data)
/*******************************************************************************
LAST MODIFIED : 29 April 2003
DESCRIPTION :
Attempts to undefine all the nodes currently in the global selection.
==============================================================================*/
{
int number_in_elements;
struct FE_field *fe_field;
struct LIST(FE_field) *fe_field_list;
struct LIST(FE_node) *node_list;
struct Node_tool *node_tool;
ENTER(Node_tool_undefine_selected_CB);
USE_PARAMETER(widget);
USE_PARAMETER(call_data);
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list))&&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)))
{
node_list = CREATE(LIST(FE_node))();
if (COPY_LIST(FE_node)(node_list,
FE_node_selection_get_node_list(node_tool->node_selection)))
{
FE_region_begin_change(node_tool->fe_region);
FE_region_undefine_FE_field_in_FE_node_list(
node_tool->fe_region, fe_field, node_list, &number_in_elements);
display_message(WARNING_MESSAGE,
"Field could not be undefined in %d node(s) "
"because in-use by elements", number_in_elements);
FE_region_end_change(node_tool->fe_region);
}
DESTROY(LIST(FE_node))(&node_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. Invalid field");
}
DESTROY(LIST(FE_field))(&fe_field_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. No field to undefine");
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_undefine_selected_CB */
#endif /* defined (MOTIF) */
static void Node_tool_reset(void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 25 February 2008
DESCRIPTION :
Resets current edit. Called on button release or when tool deactivated.
==============================================================================*/
{
struct Node_tool *node_tool;
ENTER(Node_tool_reset);
if (node_tool = (struct Node_tool *)node_tool_void)
{
REACCESS(FE_node)(&(node_tool->last_picked_node),
(struct FE_node *)NULL);
REACCESS(Interaction_volume)(
&(node_tool->last_interaction_volume),
(struct Interaction_volume *)NULL);
REACCESS(Scene_picked_object)(&(node_tool->scene_picked_object),
(struct Scene_picked_object *)NULL);
REACCESS(GT_element_group)(&(node_tool->gt_element_group),
(struct GT_element_group *)NULL);
REACCESS(GT_element_settings)(&(node_tool->gt_element_settings),
(struct GT_element_settings *)NULL);
}
else
{
display_message(ERROR_MESSAGE,"Node_tool_reset. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_reset */
static void Node_tool_interactive_event_handler(void *device_id,
struct Interactive_event *event,void *node_tool_void,
struct Graphics_buffer *graphics_buffer)
/*******************************************************************************
LAST MODIFIED : 13 February 2008
DESCRIPTION :
Input handler for input from devices. <device_id> is a unique address enabling
the editor to handle input from more than one device at a time. The <event>
describes the type of event, button numbers and key modifiers, and the volume
of space affected by the interaction. Main events are button press, movement and
release.
==============================================================================*/
{
char *command_string;
double d;
enum Glyph_scaling_mode glyph_scaling_mode;
enum Interactive_event_type event_type;
FE_value time;
int clear_selection,input_modifier,return_code,shift_pressed;
struct Computed_field *coordinate_field, *nearest_element_coordinate_field;
struct FE_element *nearest_element;
struct FE_node *picked_node;
struct FE_node_edit_information edit_info;
struct GT_element_group *gt_element_group, *gt_element_group_element;
struct GT_element_settings *gt_element_settings, *gt_element_settings_element;
struct GT_object *glyph;
struct Interaction_volume *interaction_volume,*temp_interaction_volume;
struct LIST(FE_node) *node_list;
struct LIST(Scene_picked_object) *scene_picked_object_list;
struct Node_tool *node_tool;
struct Scene *scene;
struct Scene_picked_object *scene_picked_object, *scene_picked_object2;
ENTER(Node_tool_interactive_event_handler);
if (device_id&&event&&(node_tool=
(struct Node_tool *)node_tool_void))
{
interaction_volume=Interactive_event_get_interaction_volume(event);
if (scene=Interactive_event_get_scene(event))
{
event_type=Interactive_event_get_type(event);
input_modifier=Interactive_event_get_input_modifier(event);
shift_pressed=(INTERACTIVE_EVENT_MODIFIER_SHIFT & input_modifier);
switch (event_type)
{
case INTERACTIVE_EVENT_BUTTON_PRESS:
{
/* interaction only works with first mouse button */
if (1==Interactive_event_get_button_number(event))
{
REACCESS(Interaction_volume)(&(node_tool->last_interaction_volume),
interaction_volume);
if (scene_picked_object_list=
Scene_pick_objects(scene,interaction_volume,graphics_buffer))
{
picked_node=(struct FE_node *)NULL;
nearest_element = (struct FE_element *)NULL;
if (node_tool->select_enabled)
{
picked_node=Scene_picked_object_list_get_nearest_node(
scene_picked_object_list,node_tool->use_data,
(struct Cmiss_region *)NULL,&scene_picked_object,
>_element_group,>_element_settings);
}
if (node_tool->constrain_to_surface)
{
nearest_element=Scene_picked_object_list_get_nearest_element(
scene_picked_object_list,(struct Cmiss_region *)NULL,
/*select_elements_enabled*/0, /*select_faces_enabled*/1,
/*select_lines_enabled*/0, &scene_picked_object2,
>_element_group_element,>_element_settings_element);
/* Reject the previously picked node if the element is nearer */
if (picked_node && nearest_element)
{
if (Scene_picked_object_get_nearest(scene_picked_object) >
Scene_picked_object_get_nearest(scene_picked_object2))
{
picked_node = (struct FE_node *)NULL;
}
}
}
if (picked_node)
{
node_tool->picked_node_was_unselected=
!FE_node_selection_is_node_selected(node_tool->node_selection,
picked_node);
REACCESS(Scene_picked_object)(
&(node_tool->scene_picked_object),scene_picked_object);
REACCESS(GT_element_group)(&(node_tool->gt_element_group),
gt_element_group);
REACCESS(GT_element_settings)(
&(node_tool->gt_element_settings),gt_element_settings);
if (node_tool->define_enabled)
{
if (!Computed_field_is_defined_at_node(
node_tool->coordinate_field,picked_node))
{
Node_tool_define_field_at_node_from_picked_coordinates(
node_tool,picked_node);
}
}
}
else
{
if (node_tool->create_enabled)
{
/* Find the intersection of the element and the interaction volume */
nearest_element_coordinate_field = (struct Computed_field *)NULL;
if (nearest_element)
{
if (!(nearest_element_coordinate_field =
GT_element_settings_get_coordinate_field(gt_element_settings_element)))
{
nearest_element_coordinate_field =
GT_element_group_get_default_coordinate_field(
gt_element_group_element);
}
}
/* If we are creating on elements and no element was selected then
don't create */
if (!node_tool->constrain_to_surface || nearest_element)
{
if (picked_node=Node_tool_create_node_at_interaction_volume(
node_tool,scene,interaction_volume,nearest_element,
nearest_element_coordinate_field))
{
node_tool->picked_node_was_unselected=1;
}
else
{
node_tool->picked_node_was_unselected=0;
}
}
else
{
node_tool->picked_node_was_unselected=0;
}
}
else
{
node_tool->picked_node_was_unselected=0;
}
}
REACCESS(FE_node)(&(node_tool->last_picked_node),picked_node);
DESTROY(LIST(Scene_picked_object))(&(scene_picked_object_list));
/*
* NOTE: make selection the last step so node_tool is in good state before
* receiving code gets to run: consider it capable of changing the current tool!
*/
if (clear_selection = !shift_pressed)
#if defined (OLD_CODE)
&&((!picked_node)||(node_tool->picked_node_was_unselected))))
#endif /*defined (OLD_CODE) */
{
FE_node_selection_begin_cache(node_tool->node_selection);
FE_node_selection_clear(node_tool->node_selection);
}
if (picked_node)
{
FE_node_selection_select_node(node_tool->node_selection,
picked_node);
}
if (clear_selection)
{
FE_node_selection_end_cache(node_tool->node_selection);
}
}
}
node_tool->motion_detected=0;
} break;
case INTERACTIVE_EVENT_MOTION_NOTIFY:
case INTERACTIVE_EVENT_BUTTON_RELEASE:
{
if (node_tool->last_interaction_volume&&
((INTERACTIVE_EVENT_MOTION_NOTIFY==event_type) ||
(1==Interactive_event_get_button_number(event))))
{
nearest_element = (struct FE_element *)NULL;
nearest_element_coordinate_field = (struct Computed_field *)NULL;
if (INTERACTIVE_EVENT_MOTION_NOTIFY==event_type)
{
node_tool->motion_detected=1;
}
if (node_tool->last_picked_node)
{
if (node_tool->constrain_to_surface)
{
if (scene_picked_object_list=
Scene_pick_objects(scene,interaction_volume,graphics_buffer))
{
if (nearest_element=Scene_picked_object_list_get_nearest_element(
scene_picked_object_list,(struct Cmiss_region *)NULL,
/*select_elements_enabled*/0, /*select_faces_enabled*/1,
/*select_lines_enabled*/0, &scene_picked_object2,
>_element_group_element,>_element_settings_element))
{
if (!(nearest_element_coordinate_field =
GT_element_settings_get_coordinate_field(gt_element_settings_element)))
{
nearest_element_coordinate_field =
GT_element_group_get_default_coordinate_field(
gt_element_group_element);
}
}
DESTROY(LIST(Scene_picked_object))(&(scene_picked_object_list));
}
}
if (node_tool->create_enabled &&
node_tool->streaming_create_enabled &&
(INTERACTIVE_EVENT_MOTION_NOTIFY == event_type))
{
if (!node_tool->constrain_to_surface || nearest_element)
{
if (picked_node = Node_tool_create_node_at_interaction_volume(
node_tool, scene, interaction_volume, nearest_element,
nearest_element_coordinate_field))
{
FE_node_selection_select_node(node_tool->node_selection,
picked_node);
REACCESS(FE_node)(&(node_tool->last_picked_node),
picked_node);
}
}
}
else if ((node_tool->edit_enabled)&&node_tool->motion_detected &&
(((INTERACTIVE_EVENT_MOTION_NOTIFY==event_type)&&
node_tool->motion_update_enabled)||
((INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)&&
(!node_tool->motion_update_enabled))))
{
return_code=1;
/* establish edit_info */
edit_info.last_picked_node = (struct FE_node *)NULL;
edit_info.delta1=0.0;
edit_info.delta2=0.0;
edit_info.delta3=0.0;
edit_info.initial_interaction_volume=
node_tool->last_interaction_volume;
edit_info.final_interaction_volume=interaction_volume;
edit_info.fe_region=node_tool->fe_region;
edit_info.time=Time_keeper_get_time(
node_tool->time_keeper);
edit_info.constrain_to_surface = node_tool->constrain_to_surface;
edit_info.element_xi_field = node_tool->element_xi_field;
edit_info.nearest_element = nearest_element;
edit_info.nearest_element_coordinate_field =
nearest_element_coordinate_field;
/* get coordinate field to edit */
if (node_tool->define_enabled)
{
coordinate_field=node_tool->coordinate_field;
}
else if (!(coordinate_field=
GT_element_settings_get_coordinate_field(
node_tool->gt_element_settings)))
{
coordinate_field=
GT_element_group_get_default_coordinate_field(
node_tool->gt_element_group);
}
edit_info.coordinate_field=coordinate_field;
/* get coordinate_field in RC coordinates */
edit_info.rc_coordinate_field=
Computed_field_begin_wrap_coordinate_field(coordinate_field);
edit_info.orientation_scale_field=(struct Computed_field *)NULL;
edit_info.wrapper_orientation_scale_field=
(struct Computed_field *)NULL;
if (!node_tool->gt_element_settings)
{
edit_info.glyph_centre[0] = 0.0;
edit_info.glyph_centre[1] = 0.0;
edit_info.glyph_centre[2] = 0.0;
edit_info.glyph_size[0] = 1.0;
edit_info.glyph_size[1] = 1.0;
edit_info.glyph_size[2] = 1.0;
}
else if (GT_element_settings_get_glyph_parameters(
node_tool->gt_element_settings, &glyph, &glyph_scaling_mode,
edit_info.glyph_centre,edit_info.glyph_size,
&(edit_info.orientation_scale_field),
edit_info.glyph_scale_factors,
&(edit_info.variable_scale_field)))
{
if (edit_info.orientation_scale_field)
{
edit_info.wrapper_orientation_scale_field=
Computed_field_begin_wrap_orientation_scale_field(
edit_info.orientation_scale_field,
edit_info.rc_coordinate_field);
}
}
else
{
return_code=0;
}
/* work out scene_object transformation information */
if (!node_tool->scene_picked_object)
{
/* best we can do is use world coordinates;
* will look wrong if nodes drawn with a transformation */
edit_info.transformation_required=0;
}
else if (!(Scene_picked_object_get_total_transformation_matrix(
node_tool->scene_picked_object,
&(edit_info.transformation_required),
edit_info.transformation_matrix)&&
copy_matrix(4,4,edit_info.transformation_matrix,
edit_info.LU_transformation_matrix)&&
((!edit_info.transformation_required)||
LU_decompose(4,edit_info.LU_transformation_matrix,
edit_info.LU_indx,&d,/*singular_tolerance*/1.0e-12))))
{
return_code=0;
}
if (return_code)
{
if (node_list=FE_node_selection_get_node_list(
node_tool->node_selection))
{
FE_region_begin_change(node_tool->fe_region);
/* edit vectors if non-constant orientation_scale field */
if (((NODE_TOOL_EDIT_AUTOMATIC == node_tool->edit_mode) ||
(NODE_TOOL_EDIT_VECTOR == node_tool->edit_mode))&&
edit_info.wrapper_orientation_scale_field&&
(!Computed_field_is_constant(
edit_info.orientation_scale_field)))
{
/* edit vector */
if (FE_node_calculate_delta_vector(
node_tool->last_picked_node,(void *)&edit_info))
{
FOR_EACH_OBJECT_IN_LIST(FE_node)(FE_node_edit_vector,
(void *)&edit_info,node_list);
}
}
else
{
if (NODE_TOOL_EDIT_VECTOR != node_tool->edit_mode)
{
/* edit position */
if (FE_node_calculate_delta_position(
node_tool->last_picked_node,(void *)&edit_info))
{
FOR_EACH_OBJECT_IN_LIST(FE_node)(
FE_node_edit_position,(void *)&edit_info,node_list);
}
}
else
{
display_message(ERROR_MESSAGE,"Cannot edit vector: "
"invalid orientation_scale field");
return_code=0;
}
}
FE_region_end_change(node_tool->fe_region);
}
else
{
return_code=0;
}
}
if (edit_info.orientation_scale_field)
{
Computed_field_end_wrap(
&(edit_info.wrapper_orientation_scale_field));
}
Computed_field_end_wrap(&(edit_info.rc_coordinate_field));
}
else
{
/* unselect last_picked_node if not just added */
if ((INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)&&
shift_pressed&&(!(node_tool->picked_node_was_unselected))&&
(!(node_tool->edit_enabled && node_tool->motion_detected)))
{
FE_node_selection_unselect_node(node_tool->node_selection,
node_tool->last_picked_node);
}
}
}
else if (node_tool->motion_detected)
{
/* rubber band select - make bounding box out of initial and
current interaction_volumes */
if (temp_interaction_volume=
create_Interaction_volume_bounding_box(
node_tool->last_interaction_volume,interaction_volume))
{
if (INTERACTIVE_EVENT_MOTION_NOTIFY==event_type)
{
if (!node_tool->rubber_band)
{
/* create rubber_band object and put in scene */
node_tool->rubber_band=CREATE(GT_object)(
"node_tool_rubber_band",g_POLYLINE,
node_tool->rubber_band_material);
ACCESS(GT_object)(node_tool->rubber_band);
Scene_add_graphics_object(scene,node_tool->rubber_band,
/*position*/0,"node_tool_rubber_band",
/*fast_changing*/1);
}
Interaction_volume_make_polyline_extents(
temp_interaction_volume,node_tool->rubber_band);
}
else
{
Scene_remove_graphics_object(scene,node_tool->rubber_band);
DEACCESS(GT_object)(&(node_tool->rubber_band));
}
if (INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)
{
if (scene_picked_object_list=
Scene_pick_objects(scene,temp_interaction_volume,graphics_buffer))
{
if (node_list=Scene_picked_object_list_get_picked_nodes(
scene_picked_object_list,node_tool->use_data))
{
FE_node_selection_begin_cache(node_tool->node_selection);
FOR_EACH_OBJECT_IN_LIST(FE_node)(
FE_node_select_in_FE_node_selection,
(void *)(node_tool->node_selection),node_list);
FE_node_selection_end_cache(node_tool->node_selection);
DESTROY(LIST(FE_node))(&node_list);
}
DESTROY(LIST(Scene_picked_object))(
&(scene_picked_object_list));
}
}
DESTROY(Interaction_volume)(&temp_interaction_volume);
}
}
if (INTERACTIVE_EVENT_BUTTON_RELEASE==event_type)
{
/* Execute command_field of last_picked_node as last step of button release as code
* invoked by it may modify this tool, or change to another tool before returning */
if (node_tool->last_picked_node && node_tool->command_field &&
Computed_field_is_defined_at_node(node_tool->command_field,
node_tool->last_picked_node))
{
if (node_tool->time_keeper)
{
time = Time_keeper_get_time(node_tool->time_keeper);
}
else
{
time = 0;
}
if (command_string = Computed_field_evaluate_as_string_at_node(
node_tool->command_field, /*component_number*/-1,
node_tool->last_picked_node, time))
{
Execute_command_execute_string(node_tool->execute_command,
command_string);
DEALLOCATE(command_string);
}
}
Node_tool_reset((void *)node_tool);
}
else if (node_tool->last_picked_node&&
node_tool->motion_update_enabled)
{
REACCESS(Interaction_volume)(
&(node_tool->last_interaction_volume),interaction_volume);
}
}
} break;
default:
{
display_message(ERROR_MESSAGE,
"Node_tool_interactive_event_handler. "
"Unknown event type");
} break;
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_interactive_event_handler. Invalid argument(s)");
}
LEAVE;
} /* Node_tool_interactive_event_handler */
#if defined (WX_USER_INTERFACE)
static int Node_tool_destroy_node_tool(void **node_tool_void)
/*******************************************************************************
LAST MODIFIED : 6 July 2007
DESCRIPTION :
Function to call DESTROY
==============================================================================*/
{
ENTER(Node_tool_destroy_node_tool);
Node_tool *node_tool;
int return_code;
return_code=0;
if (node_tool = (struct Node_tool *)*node_tool_void)
{
return_code = DESTROY(Node_tool)(&node_tool);
}
LEAVE;
return (return_code);
}
#endif /*defined (WX_USER_INTERFACE)*/
static int Node_tool_bring_up_interactive_tool_dialog(void *node_tool_void,
struct Graphics_window *graphics_window)
/*******************************************************************************
LAST MODIFIED : 20 June 2001
DESCRIPTION :
Brings up a dialog for editing settings of the Node_tool - in a standard format
for passing to an Interactive_toolbar.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_bring_up_interactive_tool_dialog);
return_code = Node_tool_pop_up_dialog((struct Node_tool *)node_tool_void,
graphics_window);
LEAVE;
return (return_code);
} /* Node_tool_bring_up_interactive_tool_dialog */
static struct Cmgui_image *Node_tool_get_icon(struct Colour *foreground,
struct Colour *background, void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 5 July 2002
DESCRIPTION :
Fetches the appropriate icon for the interactive tool.
==============================================================================*/
{
#if defined (MOTIF)
char *icon_name;
Display *display;
Pixel background_pixel, foreground_pixel;
Pixmap pixmap;
#endif /* defined (MOTIF) */
struct Cmgui_image *image;
struct Node_tool *node_tool;
ENTER(node_tool_get_icon);
if ((node_tool=(struct Node_tool *)node_tool_void))
{
#if defined (MOTIF)
if (MrmOpenHierarchy_binary_string(node_tool_uidh,sizeof(node_tool_uidh),
&node_tool_hierarchy,&node_tool_hierarchy_open))
{
if (node_tool->use_data)
{
icon_name="data_tool_icon";
}
else
{
icon_name="node_tool_icon";
}
display = node_tool->display;
convert_Colour_to_Pixel(display, foreground, &foreground_pixel);
convert_Colour_to_Pixel(display, background, &background_pixel);
if (MrmSUCCESS == MrmFetchIconLiteral(node_tool_hierarchy,
icon_name,DefaultScreenOfDisplay(display),display,
foreground_pixel, background_pixel, &pixmap))
{
image = create_Cmgui_image_from_Pixmap(display, pixmap);
}
else
{
display_message(WARNING_MESSAGE, "Node_tool_get_icon. "
"Could not fetch widget");
image = (struct Cmgui_image *)NULL;
}
}
else
{
display_message(WARNING_MESSAGE, "Node_tool_get_icon. "
"Could not open heirarchy");
image = (struct Cmgui_image *)NULL;
}
#else /* defined (MOTIF) */
USE_PARAMETER(foreground);
USE_PARAMETER(background);
USE_PARAMETER(node_tool);
display_message(WARNING_MESSAGE, "Node_tool_get_icon. "
"Not implemented for this user interface.");
#endif /* defined (MOTIF) */
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_icon. Invalid argument(s)");
image = (struct Cmgui_image *)NULL;
}
LEAVE;
return (image);
} /* Node_tool_get_icon */
#if defined (WX_USER_INTERFACE)
class wxNodeTool : public wxPanel
{
Node_tool *node_tool;
FE_region *master_fe_region;
FE_field *fe_field;
wxCheckBox *button_select;
wxCheckBox *button_edit;
wxCheckBox *button_motion_update;
wxCheckBox *button_define;
wxCheckBox *button_create;
wxCheckBox *button_streaming;
wxCheckBox *button_constrain;
wxButton *button_destroy;
wxButton *button_undefine;
wxWindow *Title;
wxRegionChooser *region_chooser;
wxCheckBox *node_command_field_checkbox;
wxPanel *node_command_field_chooser_panel;
wxCheckBox *element_xi_field_checkbox;
wxPanel *element_xi_field_chooser_panel;
wxPanel *cmgui_node_tool;
wxButton *clear_button;
wxCheckBox *create_elements_checkbox;
wxTextCtrl *dimension_textctrl;
wxListBox *new_element_nodes_listbox;
wxStaticText *new_element_statictext, *dimension_statictext;
wxWindow *first_element_staticbox,*second_element_staticbox;
char temp_string[20];
DEFINE_MANAGER_CLASS(Computed_field);
Managed_object_chooser<Computed_field, MANAGER_CLASS(Computed_field)>
*computed_field_chooser;
Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
*node_command_field_chooser;
Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
*element_xi_field_chooser;
public:
wxNodeTool(Node_tool *node_tool, wxPanel *parent):
node_tool(node_tool)
{
struct Computed_field *command_field, *element_xi_field;
{ // Suppress the error message if we have already initialised this xrc
wxLogNull logNo;
wxXmlInit_node_tool();
} // ~wxLogNull called, old log restored
wxXmlResource::Get()->LoadPanel(this, parent, _T("CmguiNodeTool"));
button_select = XRCCTRL(*this, "ButtonSelect", wxCheckBox);
button_edit = XRCCTRL(*this, "ButtonEdit", wxCheckBox);
button_motion_update=XRCCTRL(*this, "ButtonMotionUpdate", wxCheckBox);
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
button_streaming = XRCCTRL(*this, "ButtonStreaming", wxCheckBox);
button_constrain = XRCCTRL(*this, "ButtonConstrain", wxCheckBox );
button_select->SetValue(node_tool->select_enabled);
button_edit->SetValue(node_tool->edit_enabled);
button_motion_update->SetValue(node_tool->motion_update_enabled);
button_define->SetValue(node_tool->define_enabled);
button_create->SetValue(node_tool->create_enabled);
button_streaming->SetValue(node_tool->streaming_create_enabled);
button_constrain ->SetValue(node_tool->constrain_to_surface);
create_elements_checkbox = XRCCTRL(*this, "CreateElementsCheckBox", wxCheckBox );
dimension_textctrl = XRCCTRL(*this, "DimensionTextCtrl", wxTextCtrl);
clear_button = XRCCTRL(*this, "ClearButton", wxButton);
new_element_nodes_listbox = XRCCTRL(*this, "NewElementNodesListBox", wxListBox);
new_element_statictext = XRCCTRL(*this, "NewElementStaticText",wxStaticText);
dimension_statictext = XRCCTRL(*this, "DimensionStaticText",wxStaticText);
first_element_staticbox = XRCCTRL(*this, "FirstElementStaticBox",wxWindow);
second_element_staticbox = XRCCTRL(*this, "SecondElementStaticBox",wxWindow);
Title = XRCCTRL(*this,"NodeSizer",wxWindow);
if (node_tool->use_data)
{
Title->SetLabel("Data Tool");
create_elements_checkbox->Hide();
dimension_textctrl->Hide();
clear_button->Hide();
new_element_nodes_listbox->Hide();
new_element_statictext->Hide();
dimension_statictext->Hide();
first_element_staticbox->Hide();
second_element_staticbox->Hide();
}
else
{
Title->SetLabel("Node Tool");
create_elements_checkbox->Show();
dimension_textctrl->Show();
clear_button->Show();
new_element_nodes_listbox->Show();
new_element_statictext->Show();
dimension_statictext->Show();
create_elements_checkbox->SetValue(node_tool->element_create_enabled);
sprintf(temp_string,"%d",node_tool->element_dimension);
dimension_textctrl->ChangeValue(temp_string);
first_element_staticbox->Show();
second_element_staticbox->Show();
}
wxPanel *coordinate_field_chooser_panel =
XRCCTRL(*this, "CoordinateFieldChooserPanel", wxPanel);
computed_field_chooser =
new Managed_object_chooser<Computed_field, MANAGER_CLASS(Computed_field)>
(coordinate_field_chooser_panel, node_tool->coordinate_field,
node_tool->computed_field_manager,
Computed_field_has_up_to_3_numerical_components,
(void *)NULL, node_tool->user_interface);
Callback_base<Computed_field* > *coordinate_field_callback =
new Callback_member_callback< Computed_field*,
wxNodeTool, int (wxNodeTool::*)(Computed_field *) >
(this, &wxNodeTool::coordinate_field_callback);
computed_field_chooser->set_callback(coordinate_field_callback);
wxPanel *region_chooser_panel =
XRCCTRL(*this, "RegionChooserPanel", wxPanel);
char *initial_path;
Cmiss_region_get_root_region_path(&initial_path);
region_chooser = new wxRegionChooser(region_chooser_panel,
node_tool->root_region, initial_path);
DEALLOCATE(initial_path);
Callback_base<Cmiss_region* > *region_callback =
new Callback_member_callback< Cmiss_region*,
wxNodeTool, int (wxNodeTool::*)(Cmiss_region *) >
(this, &wxNodeTool::region_callback);
region_chooser->set_callback(region_callback);
if (node_tool->current_region_path != NULL)
{
wx_Node_tool_set_region_path(node_tool->current_region_path);
}
node_command_field_checkbox = XRCCTRL(*this, "NodeCommandFieldCheckBox",wxCheckBox);
node_command_field_chooser_panel = XRCCTRL(*this, "NodeCommandFieldChooserPanel", wxPanel);
command_field = Node_tool_get_command_field(node_tool);
node_command_field_chooser =
new Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
(node_command_field_chooser_panel, command_field, node_tool->computed_field_manager,
Computed_field_has_string_value_type, (void *)NULL, node_tool->user_interface);
Callback_base< Computed_field* > *node_command_field_callback =
new Callback_member_callback< Computed_field*,
wxNodeTool, int (wxNodeTool::*)(Computed_field *) >
(this, &wxNodeTool::node_command_field_callback);
node_command_field_chooser->set_callback(node_command_field_callback);
if (command_field == NULL)
{
node_command_field_checkbox->SetValue(0);
node_command_field_chooser_panel->Disable();
}
else
{
node_command_field_checkbox->SetValue(1);
node_command_field_chooser_panel->Enable();
}
element_xi_field_checkbox = XRCCTRL(*this, "ElementXiFieldCheckBox",wxCheckBox);
element_xi_field_chooser_panel = XRCCTRL(*this, "ElementXiFieldChooserPanel", wxPanel);
element_xi_field = Node_tool_get_element_xi_field(node_tool);
element_xi_field_chooser =
new Managed_object_chooser<Computed_field,MANAGER_CLASS(Computed_field)>
(element_xi_field_chooser_panel, element_xi_field, node_tool->computed_field_manager,
Computed_field_has_element_xi_fe_field, (void *)NULL, node_tool->user_interface);
Callback_base< Computed_field* > *element_xi_field_callback =
new Callback_member_callback< Computed_field*,
wxNodeTool, int (wxNodeTool::*)(Computed_field *) >
(this, &wxNodeTool::element_xi_field_callback);
element_xi_field_chooser->set_callback(element_xi_field_callback);
if (element_xi_field == NULL)
{
element_xi_field_checkbox->SetValue(0);
element_xi_field_chooser_panel->Disable();
}
else
{
element_xi_field_checkbox->SetValue(1);
element_xi_field_chooser_panel->Enable();
}
cmgui_node_tool = XRCCTRL(*this, "CmguiNodeTool", wxPanel);
cmgui_node_tool->SetScrollbar(wxVERTICAL,0,-1,-1);
cmgui_node_tool -> Layout();
}
wxNodeTool() /* Void constructor required for IMPLEMENT_DYNAMIC_CLASS */
{
}
~wxNodeTool()
{
if (computed_field_chooser)
delete computed_field_chooser;
if (region_chooser)
delete region_chooser;
if (node_command_field_chooser)
delete node_command_field_chooser;
if (element_xi_field_chooser)
delete element_xi_field_chooser;
}
int coordinate_field_callback(Computed_field *field)
/*******************************************************************************
LAST MODIFIED : 9 February 2007
DESCRIPTION :
Callback from wxChooser<Computed_field> when choice is made.
==============================================================================*/
{
Node_tool_set_coordinate_field(node_tool, field);
return 1;
}
int region_callback(Cmiss_region *region)
/*******************************************************************************
LAST MODIFIED : 9 February 2007
DESCRIPTION :
Callback from wxChooser<Computed_field> when choice is made.
==============================================================================*/
{
Node_tool_set_Cmiss_region(node_tool, region);
return 1;
}
int setCoordinateField(Computed_field *field)
/*******************************************************************************
LAST MODIFIED : 9 February 2007
DESCRIPTION :
Set the selected option in the Coordinate Field chooser.
==============================================================================*/
{
computed_field_chooser->set_object(field);
return 1;
}
int node_command_field_callback(Computed_field *command_field)
{
Node_tool_set_command_field(node_tool, command_field);
return 1;
}
int element_xi_field_callback(Computed_field *element_xi_field)
{
Node_tool_set_element_xi_field(node_tool, element_xi_field);
return 1;
}
void OnButtonSelectpressed(wxCommandEvent& event)
{
button_select = XRCCTRL(*this, "ButtonSelect", wxCheckBox);
Node_tool_set_select_enabled(node_tool,button_select->IsChecked());
}
void OnButtonEditpressed(wxCommandEvent& event)
{
button_edit = XRCCTRL(*this, "ButtonEdit", wxCheckBox);
Node_tool_set_edit_enabled(node_tool,button_edit->IsChecked());
}
void OnButtonMotionUpdatepressed(wxCommandEvent& event)
{
button_motion_update = XRCCTRL(*this, "ButtonMotionUpdate", wxCheckBox);
Node_tool_set_motion_update_enabled(node_tool,button_motion_update->IsChecked());
}
void OnButtonDefinepressed(wxCommandEvent& event)
{
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
Node_tool_set_define_enabled(node_tool,button_define->IsChecked());
if (!button_define->IsChecked())
{
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
button_create->SetValue(0);
Node_tool_set_create_enabled(node_tool,button_create->IsChecked());
}
}
void OnButtonCreatepressed(wxCommandEvent& event)
{
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
Node_tool_set_create_enabled(node_tool,button_create->IsChecked());
if (button_create->IsChecked())
{
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
button_define->SetValue(1);
Node_tool_set_define_enabled(node_tool,button_define->IsChecked());
}
}
void OnButtonStreamingpressed(wxCommandEvent& event)
{
button_streaming = XRCCTRL(*this, "ButtonStreaming", wxCheckBox);
Node_tool_set_streaming_create_enabled(node_tool,button_streaming->IsChecked());
}
void OnButtonConstrainpressed(wxCommandEvent& event)
{
button_constrain = XRCCTRL(*this, "ButtonConstrain", wxCheckBox );
Node_tool_set_constrain_to_surface(node_tool,button_constrain->IsChecked());
}
void OnButtonDestroypressed(wxCommandEvent& event)
{
struct LIST(FE_node) *destroy_node_list;
button_destroy = XRCCTRL(*this, "ButtonDestroy", wxButton);;
if (destroy_node_list=CREATE(LIST(FE_node))())
{
COPY_LIST(FE_node)(destroy_node_list,
FE_node_selection_get_node_list(node_tool->node_selection));
/* nodes destroyed only if removed from ultimate master FE_region */
if (FE_region_get_ultimate_master_FE_region(node_tool->fe_region,
&master_fe_region))
{
FE_region_begin_change(master_fe_region);
FE_region_remove_FE_node_list(master_fe_region, destroy_node_list);
FE_region_end_change(master_fe_region);
}
DESTROY(LIST(FE_node))(&destroy_node_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_destroy_selected_CB. Invalid argument(s)");
}
LEAVE;
}
void OnButtonUndefinepressed(wxCommandEvent& event)
{
int number_in_elements;
struct LIST(FE_field) *fe_field_list;
struct LIST(FE_node) *node_list;
button_undefine = XRCCTRL(*this, "ButtonUndefine", wxButton);
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list))&&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)))
{
node_list = CREATE(LIST(FE_node))();
if (COPY_LIST(FE_node)(node_list,
FE_node_selection_get_node_list(node_tool->node_selection)))
{
FE_region_begin_change(node_tool->fe_region);
FE_region_undefine_FE_field_in_FE_node_list(
node_tool->fe_region, fe_field, node_list, &number_in_elements);
display_message(WARNING_MESSAGE,
"Field could not be undefined in %d node(s) "
"because in-use by elements", number_in_elements);
FE_region_end_change(node_tool->fe_region);
}
DESTROY(LIST(FE_node))(&node_list);
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_undefine_selected_CB. Invalid field");
}
DESTROY(LIST(FE_field))(&fe_field_list);
}
}
void OnClearButtonpressed(wxCommandEvent &event)
{
if (node_tool)
{
Node_tool_end_element_creation(node_tool);
}
else
{
display_message(ERROR_MESSAGE,
"Element_creator_abort_creation_CB. Invalid argument(s)");
}
}
void OnCreateElementsPressed(wxCommandEvent &event)
{
create_elements_checkbox = XRCCTRL(*this, "CreateElementsCheckBox", wxCheckBox );
if (node_tool)
{
Node_tool_set_element_create_enabled(node_tool,
create_elements_checkbox->IsChecked());
}
else
{
display_message(ERROR_MESSAGE,
"Element_creator_create_button_CB. Invalid argument(s)");
}
}
void OnDimensionEntered(wxCommandEvent &event)
{
char *value_string;
int element_dimension;
dimension_textctrl = XRCCTRL(*this, "DimensionTextCtrl", wxTextCtrl);
if (node_tool)
{
if (value_string=const_cast<char *>((dimension_textctrl->GetValue()).c_str()))
{
if (1==sscanf(value_string,"%d",&element_dimension))
{
Node_tool_set_element_dimension(node_tool,
element_dimension);
}
}
/* always restore element_dimension_text to actual value stored */
Node_tool_refresh_element_dimension_text(node_tool);
}
else
{
display_message(ERROR_MESSAGE,
"Element_creator_element_dimension_text_CB. Invalid argument(s)");
}
}
void NodeToolInterfaceRenew_element_xi_field(Node_tool *node_tool)
{
struct Computed_field *element_xi_field = Node_tool_get_element_xi_field(node_tool);
element_xi_field_checkbox->SetValue(element_xi_field != 0);
if (element_xi_field)
{
element_xi_field_chooser->set_object(element_xi_field);
element_xi_field_chooser_panel->Enable();
}
else
{
element_xi_field_chooser_panel->Disable();
}
}
void NodeToolInterfaceRenew(Node_tool *destination_node_tool)
{
button_select = XRCCTRL(*this, "ButtonSelect", wxCheckBox);
button_edit = XRCCTRL(*this, "ButtonEdit", wxCheckBox);
button_motion_update=XRCCTRL(*this, "ButtonMotionUpdate", wxCheckBox);
button_define = XRCCTRL(*this, "ButtonDefine", wxCheckBox);
button_create = XRCCTRL(*this, "ButtonCreate", wxCheckBox);
button_streaming = XRCCTRL(*this, "ButtonStreaming", wxCheckBox);
button_constrain = XRCCTRL(*this, "ButtonConstrain", wxCheckBox );
create_elements_checkbox = XRCCTRL(*this, "CreateElementsCheckBox", wxCheckBox );
dimension_textctrl = XRCCTRL(*this, "DimensionTextCtrl", wxTextCtrl);
button_select->SetValue(destination_node_tool->select_enabled);
button_edit->SetValue(destination_node_tool->edit_enabled);
button_motion_update->SetValue(destination_node_tool->motion_update_enabled);
button_define->SetValue(destination_node_tool->define_enabled);
button_create->SetValue(destination_node_tool->create_enabled);
button_streaming->SetValue(destination_node_tool->streaming_create_enabled);
button_constrain->SetValue(destination_node_tool->constrain_to_surface);
NodeToolInterfaceRenew_element_xi_field(destination_node_tool);
computed_field_chooser->set_object(destination_node_tool->coordinate_field);
if (destination_node_tool->current_region_path != NULL)
{
wx_Node_tool_set_region_path(destination_node_tool->current_region_path);
}
Node_tool_set_element_dimension(destination_node_tool,destination_node_tool->element_dimension);
create_elements_checkbox->SetValue(destination_node_tool->element_create_enabled);
}
void NodeCommandFieldChecked(wxCommandEvent &event)
{
struct Computed_field *command_field = (struct Computed_field *)NULL;
if (node_command_field_checkbox->IsChecked() &&
(command_field = node_command_field_chooser->get_object()))
{
node_command_field_chooser_panel->Enable();
}
else
{
node_command_field_checkbox->SetValue(0);
node_command_field_chooser_panel->Disable();
}
Node_tool_set_command_field(node_tool, command_field);
}
void ElementXiFieldChecked(wxCommandEvent &event)
{
struct Computed_field *element_xi_field = (struct Computed_field *)NULL;
if (element_xi_field_checkbox->IsChecked() &&
(element_xi_field = element_xi_field_chooser->get_object()))
{
element_xi_field_chooser_panel->Enable();
}
else
{
element_xi_field_checkbox->SetValue(0);
element_xi_field_chooser_panel->Disable();
}
Node_tool_set_element_xi_field(node_tool, element_xi_field);
}
int wx_Node_tool_get_region_path(char **path_address)
{
if (region_chooser == NULL )
{
*path_address = region_chooser->get_path();
}
else
{
Cmiss_region_get_root_region_path(path_address);
}
return 1;
}
void wx_Node_tool_set_region_path(char *path)
{
if (path && (region_chooser != NULL))
{
/* path must start with '/' to match items in chooser */
if (path[0] != '/')
{
char *temp = NULL;
if (ALLOCATE(temp,char,strlen(path)+2))
{
strcpy(temp, "/");
strcat(temp, path);
region_chooser->set_path(temp);
DEALLOCATE(temp);
}
else
{
display_message(ERROR_MESSAGE,
"wx_Node_tool_set_region_path. Insufficient memory");
}
}
else
{
region_chooser->set_path(path);
}
}
}
struct Cmiss_region *wx_Node_tool_get_region()
{
if (region_chooser)
{
return (region_chooser->get_region());
}
else
{
return (node_tool->root_region);
}
}
DECLARE_DYNAMIC_CLASS(wxNodeTool);
DECLARE_EVENT_TABLE();
};
IMPLEMENT_DYNAMIC_CLASS(wxNodeTool, wxPanel)
BEGIN_EVENT_TABLE(wxNodeTool, wxPanel)
EVT_CHECKBOX(XRCID("ButtonSelect"),wxNodeTool::OnButtonSelectpressed)
EVT_CHECKBOX(XRCID("ButtonEdit"),wxNodeTool::OnButtonEditpressed)
EVT_CHECKBOX(XRCID("ButtonMotionUpdate"),wxNodeTool::OnButtonMotionUpdatepressed)
EVT_CHECKBOX(XRCID("ButtonDefine"),wxNodeTool::OnButtonDefinepressed)
EVT_CHECKBOX(XRCID("ButtonCreate"),wxNodeTool::OnButtonCreatepressed)
EVT_CHECKBOX(XRCID("ButtonStreaming"),wxNodeTool::OnButtonStreamingpressed)
EVT_CHECKBOX(XRCID("ButtonConstrain"),wxNodeTool::OnButtonConstrainpressed)
EVT_CHECKBOX(XRCID("ElementXiFieldCheckBox"),wxNodeTool::ElementXiFieldChecked)
EVT_CHECKBOX(XRCID("NodeCommandFieldCheckBox"),wxNodeTool::NodeCommandFieldChecked)
EVT_BUTTON(XRCID("ButtonDestroy"),wxNodeTool::OnButtonDestroypressed)
EVT_BUTTON(XRCID("ButtonUndefine"),wxNodeTool::OnButtonUndefinepressed)
EVT_BUTTON(XRCID("ClearButton"),wxNodeTool::OnClearButtonpressed)
EVT_CHECKBOX(XRCID("CreateElementsCheckBox"),wxNodeTool::OnCreateElementsPressed)
EVT_TEXT_ENTER(XRCID("DimensionTextCtrl"),wxNodeTool::OnDimensionEntered)
END_EVENT_TABLE()
#endif /* defined (WX_USER_INTERFACE) */
/*
Global functions
----------------
*/
#if defined (WX_USER_INTERFACE)
void Node_tool_set_wx_interface(void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 13 April 2007
DESCRIPTION :
Set the wx_interface for new settings.
==============================================================================*/
{
struct Node_tool *node_tool;
if (node_tool=(struct Node_tool *)node_tool_void)
{
if (node_tool->wx_node_tool != (wxNodeTool *) NULL)
{
node_tool->wx_node_tool->NodeToolInterfaceRenew(node_tool);
}
}
}
#endif /*(WX_USER_INTERFACE)*/
static int Node_tool_copy_function(
void *destination_tool_void, void *source_tool_void,
struct MANAGER(Interactive_tool) *destination_tool_manager)
/*******************************************************************************
LAST MODIFIED : 29 March 2007
DESCRIPTION :
Copies the state of one node tool to another.
==============================================================================*/
{
int return_code;
struct Node_tool *destination_node_tool, *source_node_tool;
ENTER(Node_tool_copy_function);
if ((destination_tool_void || destination_tool_manager) &&
(source_node_tool=(struct Node_tool *)source_tool_void))
{
if (destination_tool_void)
{
destination_node_tool = (struct Node_tool *)destination_tool_void;
}
else
{
destination_node_tool = CREATE(Node_tool)(
destination_tool_manager,
source_node_tool->root_region,
source_node_tool->use_data,
source_node_tool->node_selection,
source_node_tool->computed_field_package,
source_node_tool->rubber_band_material,
source_node_tool->user_interface,
source_node_tool->time_keeper,
source_node_tool->execute_command);
}
if (destination_node_tool)
{
destination_node_tool->coordinate_field = source_node_tool->coordinate_field;
destination_node_tool->create_enabled = source_node_tool->create_enabled;
destination_node_tool->define_enabled = source_node_tool->define_enabled;
destination_node_tool->edit_enabled= source_node_tool->edit_enabled;
destination_node_tool->motion_update_enabled= source_node_tool->motion_update_enabled;
destination_node_tool->select_enabled = source_node_tool->select_enabled;
destination_node_tool->streaming_create_enabled = source_node_tool->streaming_create_enabled;
destination_node_tool->constrain_to_surface= source_node_tool->constrain_to_surface;
destination_node_tool->command_field = source_node_tool->command_field;
destination_node_tool->element_xi_field = source_node_tool->element_xi_field;
#if ! defined (MOTIF)
destination_node_tool->current_region_path= source_node_tool->current_region_path;
#endif /* ! defined (MOTIF) */
destination_node_tool->element_create_enabled = source_node_tool->element_create_enabled;
destination_node_tool->element_dimension = source_node_tool->element_dimension;
Node_tool_set_Cmiss_region(destination_node_tool,
source_node_tool->region);
#if defined (WX_USER_INTERFACE)
if (destination_node_tool->wx_node_tool != (wxNodeTool *) NULL)
{
destination_node_tool->wx_node_tool->NodeToolInterfaceRenew(destination_node_tool);
}
return_code=1;
#endif /*(WX_USER_INTERFACE)*/
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_copy_function. Could not create copy.");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_copy_function. Invalid argument(s)");
return_code=0;
}
return (return_code);
} /* Node_tool_copy_function */
struct Node_tool *CREATE(Node_tool)(
struct MANAGER(Interactive_tool) *interactive_tool_manager,
struct Cmiss_region *root_region, int use_data,
struct FE_node_selection *node_selection,
struct Computed_field_package *computed_field_package,
struct Graphical_material *rubber_band_material,
struct User_interface *user_interface,
struct Time_keeper *time_keeper,
struct Execute_command *execute_command)
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Creates a Node_tool for editing nodes/data in the <node_manager>,
using the <node_selection>.
The <use_data> flag indicates that <node_manager> and <node_selection>
refer to data, not nodes, needed since different GT_element_settings types are
used to represent them. <element_manager> should be NULL if <use_data> is true.
==============================================================================*/
{
char *initial_path;
char *tool_display_name,*tool_name;
#if defined (MOTIF)
Atom WM_DELETE_WINDOW;
int init_widgets;
MrmType node_tool_dialog_class;
static MrmRegisterArg callback_list[]=
{
{"node_tool_id_select_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,select_button)},
{"node_tool_id_edit_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,edit_button)},
{"node_tool_id_motion_update_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,motion_update_button)},
{"node_tool_id_define_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,define_button)},
{"node_tool_id_create_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,create_button)},
{"node_tool_id_streaming_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,streaming_create_button)},
{"node_tool_id_constrain_srf_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,constrain_to_surface_button)},
{"node_tool_id_node_group_form",(XtPointer)
DIALOG_IDENTIFY(node_tool,node_group_form)},
{"node_tool_id_coord_field_form",(XtPointer)
DIALOG_IDENTIFY(node_tool,coordinate_field_form)},
{"node_tool_id_command_field_btn",(XtPointer)
DIALOG_IDENTIFY(node_tool,command_field_button)},
{"node_tool_id_command_field_form",(XtPointer)
DIALOG_IDENTIFY(node_tool,command_field_form)},
{"node_tool_select_btn_CB",
(XtPointer)Node_tool_select_button_CB},
{"node_tool_edit_btn_CB",
(XtPointer)Node_tool_edit_button_CB},
{"node_tool_motion_update_btn_CB",
(XtPointer)Node_tool_motion_update_button_CB},
{"node_tool_define_btn_CB",
(XtPointer)Node_tool_define_button_CB},
{"node_tool_create_btn_CB",
(XtPointer)Node_tool_create_button_CB},
{"node_tool_streaming_btn_CB",
(XtPointer)Node_tool_streaming_create_button_CB},
{"node_tool_constrain_srf_btn_CB",
(XtPointer)Node_tool_constrain_to_surface_button_CB},
{"node_tool_command_field_btn_CB",
(XtPointer)Node_tool_command_field_button_CB},
{"node_tool_destroy_selected_CB",
(XtPointer)Node_tool_destroy_selected_CB},
{"node_tool_undefine_selected_CB",
(XtPointer)Node_tool_undefine_selected_CB}
};
static MrmRegisterArg identifier_list[]=
{
{"node_tool_structure",(XtPointer)NULL}
};
struct Callback_data callback;
struct Cmiss_region *region;
#endif /* defined (MOTIF) */
struct MANAGER(Computed_field) *computed_field_manager;
struct Node_tool *node_tool;
ENTER(CREATE(Node_tool));
node_tool=(struct Node_tool *)NULL;
if (interactive_tool_manager&&root_region&&node_selection&&
computed_field_package&&(computed_field_manager=
Computed_field_package_get_computed_field_manager(computed_field_package))
&&rubber_band_material&&user_interface&&execute_command)
{
Cmiss_region_get_root_region_path(&initial_path);
if (ALLOCATE(node_tool,struct Node_tool,1))
{
node_tool->execute_command=execute_command;
node_tool->interactive_tool_manager=interactive_tool_manager;
node_tool->root_region=root_region;
node_tool->region=(struct Cmiss_region *)NULL;
node_tool->fe_region=(struct FE_region *)NULL;
node_tool->use_data = use_data;
node_tool->node_selection=node_selection;
node_tool->computed_field_package=computed_field_package;
node_tool->rubber_band_material=
ACCESS(Graphical_material)(rubber_band_material);
node_tool->user_interface=user_interface;
node_tool->time_keeper = (struct Time_keeper *)NULL;
if (time_keeper)
{
node_tool->time_keeper = ACCESS(Time_keeper)(time_keeper);
}
/* user-settable flags */
node_tool->select_enabled=1;
node_tool->edit_enabled=0;
node_tool->motion_update_enabled=1;
node_tool->define_enabled=0;
node_tool->create_enabled=0;
node_tool->streaming_create_enabled=0;
node_tool->constrain_to_surface=0;
/* settings of the element creator */
node_tool->FE_coordinate_field = (struct FE_field *)NULL;
node_tool->element_dimension = 2;
node_tool->template_element = (struct FE_element *)NULL;
node_tool->element_create_enabled = 0;
node_tool->element = (struct FE_element *)NULL;
node_tool->number_of_clicked_nodes = 0;
node_tool->edit_mode=NODE_TOOL_EDIT_AUTOMATIC;
node_tool->coordinate_field =
FIRST_OBJECT_IN_MANAGER_THAT(Computed_field)(
Computed_field_has_up_to_3_numerical_components, (void *)NULL,
computed_field_manager);
node_tool->command_field = (struct Computed_field *)NULL;
node_tool->element_xi_field = (struct Computed_field *)NULL;
/* interactive_tool */
if (use_data)
{
tool_name="data_tool";
tool_display_name="Data tool";
}
else
{
tool_name="node_tool";
tool_display_name="Node tool";
}
#if defined (WX_USER_INTERFACE) /* switch (USER_INTERFACE) */
node_tool->computed_field_manager=Computed_field_package_get_computed_field_manager(computed_field_package);
node_tool->wx_node_tool = (wxNodeTool *)NULL;
/* Set defaults until we have some sort of region chooser */
Node_tool_set_Cmiss_region(node_tool, node_tool->root_region);
node_tool->current_region_path = (char *)NULL;
node_tool->tool_position=wxPoint(0,0);
#elif !defined (MOTIF)
node_tool->current_region_path = (char *)NULL;
#endif /*defined (WX_USER_INTERFACE)*/
node_tool->interactive_tool=CREATE(Interactive_tool)(
tool_name,tool_display_name,
Interactive_tool_node_type_string,
Node_tool_interactive_event_handler,
Node_tool_get_icon,
Node_tool_bring_up_interactive_tool_dialog,
Node_tool_reset,
#if defined (WX_USER_INTERFACE)
Node_tool_destroy_node_tool,
#else
(Interactive_tool_destroy_tool_data_function *)NULL,
#endif /*defined (WX_USER_INTERFACE)*/
Node_tool_copy_function,
(void *)node_tool);
ADD_OBJECT_TO_MANAGER(Interactive_tool)(
node_tool->interactive_tool,
node_tool->interactive_tool_manager);
node_tool->scene_picked_object=(struct Scene_picked_object *)NULL;
node_tool->last_picked_node=(struct FE_node *)NULL;
node_tool->gt_element_group=(struct GT_element_group *)NULL;
node_tool->gt_element_settings=(struct GT_element_settings *)NULL;
node_tool->last_interaction_volume=(struct Interaction_volume *)NULL;
node_tool->rubber_band=(struct GT_object *)NULL;
#if defined (MOTIF)
/* initialise widgets */
node_tool->coordinate_field_form=(Widget)NULL;
node_tool->coordinate_field_widget=(Widget)NULL;
node_tool->cmiss_region_chooser=(struct Cmiss_region_chooser *)NULL;
node_tool->create_button=(Widget)NULL;
node_tool->define_button=(Widget)NULL;
node_tool->display = User_interface_get_display(user_interface);
node_tool->edit_button=(Widget)NULL;
node_tool->motion_update_button=(Widget)NULL;
node_tool->node_group_form=(Widget)NULL;
node_tool->node_group_widget=(Widget)NULL;
node_tool->select_button=(Widget)NULL;
node_tool->streaming_create_button=(Widget)NULL;
node_tool->constrain_to_surface_button=(Widget)NULL;
node_tool->command_field_button=(Widget)NULL;
node_tool->command_field_form=(Widget)NULL;
node_tool->command_field_widget=(Widget)NULL;
node_tool->widget=(Widget)NULL;
node_tool->window_shell=(Widget)NULL;
/* make the dialog shell */
if (MrmOpenHierarchy_binary_string(node_tool_uidh,sizeof(node_tool_uidh),
&node_tool_hierarchy,&node_tool_hierarchy_open))
{
if (node_tool->window_shell=
XtVaCreatePopupShell(tool_display_name,
topLevelShellWidgetClass,
User_interface_get_application_shell(user_interface),
XmNdeleteResponse,XmDO_NOTHING,
XmNmwmDecorations,MWM_DECOR_ALL,
XmNmwmFunctions,MWM_FUNC_ALL,
/*XmNtransient,FALSE,*/
XmNallowShellResize,False,
XmNtitle,tool_display_name,
NULL))
{
/* Set up window manager callback for close window message */
WM_DELETE_WINDOW=XmInternAtom(XtDisplay(node_tool->window_shell),
"WM_DELETE_WINDOW",False);
XmAddWMProtocolCallback(node_tool->window_shell,
WM_DELETE_WINDOW,Node_tool_close_CB,node_tool);
/* Register the shell with the busy signal list */
create_Shell_list_item(&(node_tool->window_shell),user_interface);
/* register the callbacks */
if (MrmSUCCESS==MrmRegisterNamesInHierarchy(
node_tool_hierarchy,callback_list,XtNumber(callback_list)))
{
/* assign and register the identifiers */
identifier_list[0].value=(XtPointer)node_tool;
if (MrmSUCCESS==MrmRegisterNamesInHierarchy(
node_tool_hierarchy,identifier_list,XtNumber(identifier_list)))
{
/* fetch node tool widgets */
if (MrmSUCCESS==MrmFetchWidget(node_tool_hierarchy,
"node_tool",node_tool->window_shell,
&(node_tool->widget),&node_tool_dialog_class))
{
init_widgets=1;
if (node_tool->coordinate_field_widget=
CREATE_CHOOSE_OBJECT_WIDGET(Computed_field)(
node_tool->coordinate_field_form,
node_tool->coordinate_field,computed_field_manager,
Computed_field_has_up_to_3_numerical_components,
(void *)NULL, user_interface))
{
callback.data=(void *)node_tool;
callback.procedure=Node_tool_update_coordinate_field;
CHOOSE_OBJECT_SET_CALLBACK(Computed_field)(
node_tool->coordinate_field_widget,&callback);
}
else
{
init_widgets=0;
}
if (node_tool->command_field_widget =
CREATE_CHOOSE_OBJECT_WIDGET(Computed_field)(
node_tool->command_field_form,
node_tool->command_field, computed_field_manager,
Computed_field_has_string_value_type,
(void *)NULL, user_interface))
{
callback.data = (void *)node_tool;
callback.procedure = Node_tool_update_command_field;
CHOOSE_OBJECT_SET_CALLBACK(Computed_field)(
node_tool->command_field_widget, &callback);
}
else
{
init_widgets=0;
}
if (node_tool->cmiss_region_chooser =
CREATE(Cmiss_region_chooser)(node_tool->node_group_form,
node_tool->root_region, initial_path))
{
if (Cmiss_region_chooser_get_region(
node_tool->cmiss_region_chooser, ®ion))
{
Node_tool_set_Cmiss_region(node_tool, region);
}
Cmiss_region_chooser_set_callback(
node_tool->cmiss_region_chooser,
Node_tool_update_region,
(void *)node_tool);
}
else
{
init_widgets=0;
}
if (init_widgets)
{
XmToggleButtonGadgetSetState(node_tool->create_button,
/*state*/node_tool->create_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->define_button,
/*state*/node_tool->define_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->edit_button,
/*state*/node_tool->edit_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->motion_update_button,
/*state*/node_tool->motion_update_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->select_button,
/*state*/node_tool->select_enabled,/*notify*/False);
XmToggleButtonGadgetSetState(
node_tool->streaming_create_button,
/*state*/node_tool->streaming_create_enabled,
/*notify*/False);
XmToggleButtonGadgetSetState(
node_tool->constrain_to_surface_button,
/*state*/node_tool->constrain_to_surface,
/*notify*/False);
XmToggleButtonGadgetSetState(node_tool->command_field_button,
/*state*/False, /*notify*/False);
XtSetSensitive(node_tool->command_field_widget, /*state*/False);
XtManageChild(node_tool->widget);
XtRealizeWidget(node_tool->window_shell);
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not init widgets");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not fetch node_tool");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not register identifiers");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not register callbacks");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not create Shell");
DESTROY(Node_tool)(&node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Could not open hierarchy");
}
#endif /* defined (USER_INTERFACE) */
}
else
{
display_message(ERROR_MESSAGE,
"CREATE(Node_tool). Not enough memory");
DEALLOCATE(node_tool);
}
DEALLOCATE(initial_path);
}
else
{
display_message(ERROR_MESSAGE,"CREATE(Node_tool). Invalid argument(s)");
}
LEAVE;
return (node_tool);
} /* CREATE(Node_tool) */
int DESTROY(Node_tool)(struct Node_tool **node_tool_address)
/*******************************************************************************
LAST MODIFIED : 19 July 2000
DESCRIPTION :
Frees and deaccesses objects in the <node_tool> and deallocates the
structure itself.
==============================================================================*/
{
struct Node_tool *node_tool;
int return_code;
ENTER(DESTROY(Node_tool));
if (node_tool_address&&
(node_tool= *node_tool_address))
{
#if defined (MOTIF)
REMOVE_OBJECT_FROM_MANAGER(Interactive_tool)(
node_tool->interactive_tool,
node_tool->interactive_tool_manager);
#endif /* defined (MOTIF) */
Node_tool_reset((void *)node_tool);
REACCESS(GT_object)(&(node_tool->rubber_band),(struct GT_object *)NULL);
DEACCESS(Graphical_material)(&(node_tool->rubber_band_material));
if (node_tool->time_keeper)
{
DEACCESS(Time_keeper)(&(node_tool->time_keeper));
}
#if defined (WX_USER_INTERFACE)
if (node_tool->wx_node_tool)
node_tool->wx_node_tool->Destroy();
#endif /*(WX_USER_INTERFACE)*/
#if defined (MOTIF)
if (node_tool->window_shell)
{
destroy_Shell_list_item_from_shell(&(node_tool->window_shell),
node_tool->user_interface);
XtDestroyWidget(node_tool->window_shell);
}
#elif !defined (WX_USER_INTERFACE)
if (node_tool->current_region_path != NULL)
{
DEALLOCATE(node_tool->current_region_path);
}
#endif /* defined (MOTIF) */
DEALLOCATE(*node_tool_address);
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,"DESTROY(Node_tool). Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* DESTROY(Node_tool) */
int Node_tool_pop_up_dialog(struct Node_tool *node_tool, struct Graphics_window *graphics_window)
/*******************************************************************************
LAST MODIFIED : 20 June 2001
DESCRIPTION :
Pops up a dialog for editing settings of the Node_tool.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_pop_up_dialog);
if (node_tool)
{
#if defined (MOTIF)
XtPopup(node_tool->window_shell, XtGrabNone);
/* make sure in addition that it is not shown as an icon */
XtVaSetValues(node_tool->window_shell, XmNiconic, False, NULL);
#elif defined (WX_USER_INTERFACE) /* switch (USER_INTERFACE) */
wxPanel *pane;
if (!node_tool->wx_node_tool)
{
wxScrolledWindow *GeneralSettingPanel = Graphics_window_get_interactive_tool_panel(graphics_window);
node_tool->wx_node_tool = new wxNodeTool(node_tool,
GeneralSettingPanel);
pane = XRCCTRL(*node_tool->wx_node_tool, "CmguiNodeTool", wxPanel);
node_tool->tool_position = pane->GetPosition();
node_tool->wx_node_tool->Show();
}
else
{
pane = XRCCTRL(*node_tool->wx_node_tool, "CmguiNodeTool", wxPanel);
pane->SetPosition(node_tool->tool_position);
node_tool->wx_node_tool->Show();
}
#else /* switch (USER_INTERFACE) */
display_message(ERROR_MESSAGE, "Node_tool_pop_up_dialog. "
"No dialog implemented for this User Interface");
#endif /* switch (USER_INTERFACE) */
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_pop_up_dialog. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_pop_up_dialog */
int Node_tool_pop_down_dialog(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 20 June 2001
DESCRIPTION :
Hides the dialog for editing settings of the Node_tool.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_pop_down_dialog);
if (node_tool)
{
#if defined (MOTIF)
XtPopdown(node_tool->window_shell);
#else /* defined (MOTIF) */
display_message(ERROR_MESSAGE, "Node_tool_pop_down_dialog. "
"No dialog implemented for this User Interface");
#endif /* defined (MOTIF) */
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_pop_down_dialog. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_pop_down_dialog */
struct Computed_field *Node_tool_get_coordinate_field(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Returns the coordinate_field used by the <node_tool> when create/define are on.
==============================================================================*/
{
struct Computed_field *coordinate_field;
ENTER(Node_tool_get_coordinate_field);
if (node_tool)
{
coordinate_field=node_tool->coordinate_field;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_coordinate_field. Invalid argument(s)");
coordinate_field=(struct Computed_field *)NULL;
}
LEAVE;
return (coordinate_field);
} /* Node_tool_get_coordinate_field */
int Node_tool_set_coordinate_field(struct Node_tool *node_tool,
struct Computed_field *coordinate_field)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Sets the coordinate_field to be defined by the <node_tool> when create/define
are on.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_coordinate_field);
if (node_tool)
{
return_code=1;
if (coordinate_field != node_tool->coordinate_field)
{
node_tool->coordinate_field=coordinate_field;
#if defined (MOTIF)
/* make sure the current field is shown on the widget */
CHOOSE_OBJECT_SET_OBJECT(Computed_field)(
node_tool->coordinate_field_widget,node_tool->coordinate_field);
#endif /* defined (MOTIF) */
#if defined (WX_USER_INTERFACE)
if (node_tool->wx_node_tool)
{
node_tool->wx_node_tool->setCoordinateField(coordinate_field);
}
#endif /* defined (WX_USER_INTERFACE) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_coordinate_field. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_coordinate_field */
int Node_tool_get_create_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Returns flag controlling whether nodes can be created when none are selected
on a mouse button press.
==============================================================================*/
{
int create_enabled;
ENTER(Node_tool_get_create_enabled);
if (node_tool)
{
create_enabled=node_tool->create_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_create_enabled. Invalid argument(s)");
create_enabled=0;
}
LEAVE;
return (create_enabled);
} /* Node_tool_get_create_enabled */
int Node_tool_set_create_enabled(struct Node_tool *node_tool,
int create_enabled)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Sets flag controlling whether nodes can be created when none are selected
on a mouse button press. Also ensures define is enabled if create is.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_create_enabled);
if (node_tool)
{
return_code=1;
if (create_enabled)
{
if (node_tool->region && node_tool->coordinate_field)
{
/* make sure value of flag is exactly 1 */
create_enabled=1;
/* must also enable define */
Node_tool_set_define_enabled(node_tool,1);
}
else
{
display_message(WARNING_MESSAGE,
"Node_tool must have a group and coordinate_field to create nodes");
create_enabled=0;
return_code=0;
}
}
if (create_enabled != node_tool->create_enabled)
{
node_tool->create_enabled=create_enabled;
/* make sure button shows current state */
#if defined (MOTIF)
if (XmToggleButtonGadgetGetState(node_tool->create_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->create_enabled)
{
XmToggleButtonGadgetSetState(node_tool->create_button,
/*state*/node_tool->create_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_create_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_create_enabled */
int Node_tool_get_define_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Returns flag controlling whether nodes can be defined when none are selected
on a mouse button press.
==============================================================================*/
{
int define_enabled;
ENTER(Node_tool_get_define_enabled);
if (node_tool)
{
define_enabled=node_tool->define_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_define_enabled. Invalid argument(s)");
define_enabled=0;
}
LEAVE;
return (define_enabled);
} /* Node_tool_get_define_enabled */
int Node_tool_set_define_enabled(struct Node_tool *node_tool,
int define_enabled)
/*******************************************************************************
LAST MODIFIED : 12 September 2000
DESCRIPTION :
Sets flag controlling whether the coordinate_field can be defined on any new
or individually selected existing nodes.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_define_enabled);
if (node_tool)
{
return_code=1;
if (define_enabled)
{
if (node_tool->coordinate_field)
{
/* make sure value of flag is exactly 1 */
define_enabled=1;
}
else
{
display_message(WARNING_MESSAGE,
"Cannot enable define in Node_tool without a field to define");
define_enabled=0;
return_code=0;
}
}
else
{
/* make sure create is off */
Node_tool_set_create_enabled(node_tool,0);
}
if (define_enabled != node_tool->define_enabled)
{
node_tool->define_enabled=define_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->define_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->define_enabled)
{
XmToggleButtonGadgetSetState(node_tool->define_button,
/*state*/node_tool->define_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_define_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_define_enabled */
int Node_tool_get_edit_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int edit_enabled;
ENTER(Node_tool_get_edit_enabled);
if (node_tool)
{
edit_enabled=node_tool->edit_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_edit_enabled. Invalid argument(s)");
edit_enabled=0;
}
LEAVE;
return (edit_enabled);
} /* Node_tool_get_edit_enabled */
int Node_tool_set_edit_enabled(struct Node_tool *node_tool,int edit_enabled)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Sets flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_edit_enabled);
if (node_tool)
{
/* make sure value of flag is 1 */
if (edit_enabled)
{
edit_enabled=1;
}
if (edit_enabled != node_tool->edit_enabled)
{
node_tool->edit_enabled=edit_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->edit_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->edit_enabled)
{
XmToggleButtonGadgetSetState(node_tool->edit_button,
/*state*/node_tool->edit_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_edit_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_edit_enabled */
enum Node_tool_edit_mode Node_tool_get_edit_mode(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns the current edit mode of <node_tool>.
==============================================================================*/
{
enum Node_tool_edit_mode edit_mode;
ENTER(Node_tool_get_edit_mode);
if (node_tool)
{
edit_mode=node_tool->edit_mode;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_edit_mode. Invalid argument(s)");
/* return anything for error condition */
edit_mode=NODE_TOOL_EDIT_AUTOMATIC;
}
LEAVE;
return (edit_mode);
} /* Node_tool_get_edit_mode */
int Node_tool_set_edit_mode(struct Node_tool *node_tool,
enum Node_tool_edit_mode edit_mode)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Sets the <edit_mode> of <node_tool> - controls whether the editor
can select or edit nodes, and whether the editing is restricted to position or
vector only.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_edit_mode);
if (node_tool)
{
node_tool->edit_mode=edit_mode;
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_edit_mode. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_edit_mode */
int Node_tool_get_motion_update_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int motion_update_enabled;
ENTER(Node_tool_get_motion_update_enabled);
if (node_tool)
{
motion_update_enabled=node_tool->motion_update_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_motion_update_enabled. Invalid argument(s)");
motion_update_enabled=0;
}
LEAVE;
return (motion_update_enabled);
} /* Node_tool_get_motion_update_enabled */
int Node_tool_set_motion_update_enabled(struct Node_tool *node_tool,
int motion_update_enabled)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Sets flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_motion_update_enabled);
if (node_tool)
{
/* make sure value of flag is 1 */
if (motion_update_enabled)
{
motion_update_enabled=1;
}
if (motion_update_enabled != node_tool->motion_update_enabled)
{
node_tool->motion_update_enabled=motion_update_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->motion_update_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->motion_update_enabled)
{
XmToggleButtonGadgetSetState(node_tool->motion_update_button,
/*state*/node_tool->motion_update_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_motion_update_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_motion_update_enabled */
int Node_tool_get_region_path(struct Node_tool *node_tool,
char **path_address)
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Returns in <path_address> the path to the Cmiss_region where nodes created by
the <node_tool> are put.
Up to the calling function to DEALLOCATE the returned path.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_get_region_path);
if (node_tool && path_address)
{
#if defined (MOTIF)
return_code = Cmiss_region_chooser_get_path(node_tool->cmiss_region_chooser,
path_address);
#elif defined (WX_USER_INTERFACE)
if (node_tool->current_region_path)
{
*path_address = duplicate_string(node_tool->current_region_path);
return_code = 1;
}
else
{
Cmiss_region_get_root_region_path(path_address);
return_code = 0;
}
#else /* switch USER_INTERFACE*/
if (node_tool->current_region_path)
{
*path_address = duplicate_string(node_tool->current_region_path);
return_code = 1;
}
else
{
*path_address = (char *)NULL;
return_code = 0;
}
#endif /* defined (MOTIF) */
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_region_path. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_get_region_path */
#if defined (WX_USER_INTERFACE)
char *Node_tool_get_current_region_path(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 10 July 2007
DESCRIPTION :
Return the pointer of the node_tool->current_region_path, used for
deallocate the current region path outside whe cmiss command_data is
being destroy to prevent multiple deallocations of the same address.
==============================================================================*/
{
ENTER(Node_tool_get_region_path);
char *path;
path = NULL;
if (node_tool)
{
if (node_tool->current_region_path)
{
path = node_tool->current_region_path;
}
}
return (path);
}
#endif /* defined (WX_USER_INTERFACE) */
int Node_tool_set_region_path(struct Node_tool *node_tool,
char *path)
/*******************************************************************************
LAST MODIFIED : 17 May 2003
DESCRIPTION :
Sets the <path> to the region/FE_region where nodes created by
<node_tool> are placed.
==============================================================================*/
{
int return_code;
struct Cmiss_region *region;
ENTER(Node_tool_set_region_path);
if (node_tool && path)
{
#if defined (MOTIF)
Cmiss_region_chooser_set_path(node_tool->cmiss_region_chooser, path);
region = (struct Cmiss_region *)NULL;
Cmiss_region_chooser_get_region(node_tool->cmiss_region_chooser, ®ion);
return_code = Node_tool_set_Cmiss_region(node_tool, region);
#elif defined (WX_USER_INTERFACE)
if (node_tool->current_region_path)
{
DEALLOCATE(node_tool->current_region_path);
}
node_tool->current_region_path = duplicate_string(path);
region = (struct Cmiss_region *)NULL;
if (node_tool->wx_node_tool)
{
node_tool->wx_node_tool->wx_Node_tool_set_region_path(path);
region = node_tool->wx_node_tool->wx_Node_tool_get_region();
}
else
{
region=node_tool->root_region;
Cmiss_region_get_region_from_path(node_tool->root_region,
path, ®ion);
}
return_code = Node_tool_set_Cmiss_region(node_tool, region);
#else /* defined (MOTIF) */
if (return_code = Cmiss_region_get_region_from_path(node_tool->root_region,
path, ®ion))
{
if (node_tool->current_region_path)
{
DEALLOCATE(node_tool->current_region_path);
}
node_tool->current_region_path = duplicate_string(path);
return_code = Node_tool_set_Cmiss_region(node_tool, region);
}
#endif /* defined (MOTIF) */
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_region_path. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_region_path */
int Node_tool_get_select_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 May 2000
DESCRIPTION :
Returns flag controlling whether existing nodes can be selected.
==============================================================================*/
{
int select_enabled;
ENTER(Node_tool_get_select_enabled);
if (node_tool)
{
select_enabled=node_tool->select_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_select_enabled. Invalid argument(s)");
select_enabled=0;
}
LEAVE;
return (select_enabled);
} /* Node_tool_get_select_enabled */
int Node_tool_set_select_enabled(struct Node_tool *node_tool,
int select_enabled)
/*******************************************************************************
LAST MODIFIED : 18 July 2000
DESCRIPTION :
Sets flag controlling whether existing nodes can be selected.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_select_enabled);
if (node_tool)
{
/* make sure value of flag is 1 */
if (select_enabled)
{
select_enabled=1;
}
if (select_enabled != node_tool->select_enabled)
{
node_tool->select_enabled=select_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->select_button))
{
button_state=1;
}
else
{
button_state=0;
}
if (button_state != node_tool->select_enabled)
{
XmToggleButtonGadgetSetState(node_tool->select_button,
/*state*/node_tool->select_enabled,/*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_select_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_select_enabled */
int Node_tool_get_streaming_create_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 14 May 2001
DESCRIPTION :
Returns flag controlling, if create_enabled, whether a stream of nodes is
created as the user drags the mouse around.
==============================================================================*/
{
int streaming_create_enabled;
ENTER(Node_tool_get_streaming_create_enabled);
if (node_tool)
{
streaming_create_enabled = node_tool->streaming_create_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_streaming_create_enabled. Invalid argument(s)");
streaming_create_enabled = 0;
}
LEAVE;
return (streaming_create_enabled);
} /* Node_tool_get_streaming_create_enabled */
int Node_tool_set_streaming_create_enabled(struct Node_tool *node_tool,
int streaming_create_enabled)
/*******************************************************************************
LAST MODIFIED : 14 May 2001
DESCRIPTION :
Sets flag controlling, if create_enabled, whether a stream of nodes is
created as the user drags the mouse around.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_streaming_create_enabled);
if (node_tool)
{
if (streaming_create_enabled)
{
/* make sure value of flag is exactly 1 */
streaming_create_enabled = 1;
}
if (streaming_create_enabled != node_tool->streaming_create_enabled)
{
node_tool->streaming_create_enabled = streaming_create_enabled;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->streaming_create_button))
{
button_state = 1;
}
else
{
button_state = 0;
}
if (button_state != node_tool->streaming_create_enabled)
{
XmToggleButtonGadgetSetState(node_tool->streaming_create_button,
/*state*/node_tool->streaming_create_enabled, /*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_streaming_create_enabled. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_streaming_create_enabled */
int Node_tool_get_constrain_to_surface(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 April 2005
DESCRIPTION :
Returns flag controlling, if create_enabled, whether new nodes will be created
on the closest surface element or just halfway between near and far.
==============================================================================*/
{
int constrain_to_surface;
ENTER(Node_tool_get_constrain_to_surface);
if (node_tool)
{
constrain_to_surface = node_tool->constrain_to_surface;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_constrain_to_surface. Invalid argument(s)");
constrain_to_surface = 0;
}
LEAVE;
return (constrain_to_surface);
} /* Node_tool_get_constrain_to_surface */
int Node_tool_set_constrain_to_surface(struct Node_tool *node_tool,
int constrain_to_surface)
/*******************************************************************************
LAST MODIFIED : 18 April 2005
DESCRIPTION :
Sets flag controlling, if create_enabled, whether new nodes will be created
on the closest surface element or just halfway between near and far.
==============================================================================*/
{
int return_code;
#if defined (MOTIF)
int button_state;
#endif /* defined (MOTIF) */
ENTER(Node_tool_set_constrain_to_surface);
if (node_tool)
{
if (constrain_to_surface)
{
/* make sure value of flag is exactly 1 */
constrain_to_surface = 1;
}
if (constrain_to_surface != node_tool->constrain_to_surface)
{
node_tool->constrain_to_surface = constrain_to_surface;
#if defined (MOTIF)
/* make sure button shows current state */
if (XmToggleButtonGadgetGetState(node_tool->constrain_to_surface_button))
{
button_state = 1;
}
else
{
button_state = 0;
}
if (button_state != node_tool->constrain_to_surface)
{
XmToggleButtonGadgetSetState(node_tool->constrain_to_surface_button,
/*state*/node_tool->constrain_to_surface, /*notify*/False);
}
#endif /* defined (MOTIF) */
}
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_constrain_to_surface. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_constrain_to_surface */
struct Computed_field *Node_tool_get_element_xi_field(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 18 February 2008
DESCRIPTION :
Returns the element_xi_field to define when the node is created in the <node_tool>
and node is constrained to surface.
==============================================================================*/
{
struct Computed_field *element_xi_field;
ENTER(Node_tool_get_element_xi_field);
if (node_tool)
{
element_xi_field=node_tool->element_xi_field;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_element_xi_field. Invalid argument(s)");
element_xi_field=(struct Computed_field *)NULL;
}
LEAVE;
return (element_xi_field);
} /* Node_tool_get_element_xi_field */
int Node_tool_set_element_xi_field(struct Node_tool *node_tool,
struct Computed_field *element_xi_field)
/*******************************************************************************
LAST MODIFIED : 19 February 2008
DESCRIPTION :
Sets the element_xi_field to define when the node is created in the <node_tool>
and node is constrained to surface.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_element_xi_field);
if (node_tool && ((!element_xi_field) ||
Computed_field_has_element_xi_fe_field(element_xi_field, (void *)NULL)))
{
if (element_xi_field != node_tool->element_xi_field)
{
node_tool->element_xi_field = element_xi_field;
}
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_element_xi_field. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_element_xi_field */
struct Computed_field *Node_tool_get_command_field(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Returns the command_field to be exectued when the node is clicked on in the <node_tool>.
==============================================================================*/
{
struct Computed_field *command_field;
ENTER(Node_tool_get_command_field);
if (node_tool)
{
command_field=node_tool->command_field;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_command_field. Invalid argument(s)");
command_field=(struct Computed_field *)NULL;
}
LEAVE;
return (command_field);
} /* Node_tool_get_command_field */
int Node_tool_set_command_field(struct Node_tool *node_tool,
struct Computed_field *command_field)
/*******************************************************************************
LAST MODIFIED : 4 July 2002
DESCRIPTION :
Sets the command_field to be executed when the node is clicked on in the <node_tool>.
==============================================================================*/
{
#if defined (MOTIF)
int field_set;
#endif /* defined (MOTIF) */
int return_code;
ENTER(Node_tool_set_command_field);
if (node_tool && ((!command_field) ||
Computed_field_has_string_value_type(command_field, (void *)NULL)))
{
return_code = 1;
if (command_field != node_tool->command_field)
{
node_tool->command_field = command_field;
#if defined (MOTIF)
if (command_field)
{
CHOOSE_OBJECT_SET_OBJECT(Computed_field)(
node_tool->command_field_widget,node_tool->command_field);
}
field_set = ((struct Computed_field *)NULL != command_field);
XtVaSetValues(node_tool->command_field_button,
XmNset, field_set, NULL);
XtSetSensitive(node_tool->command_field_widget, field_set);
#endif /* defined (MOTIF) */
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_command_field. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Node_tool_set_command_field */
struct Interactive_tool *Node_tool_get_interactive_tool(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 7 April 2007
DESCRIPTION :
Returns the generic interactive_tool the represents the <node_tool>.
==============================================================================*/
{
struct Interactive_tool *interactive_tool;
ENTER(Node_tool_get_interactive_tool);
if (node_tool)
{
interactive_tool=node_tool->interactive_tool;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_interactive_tool. Invalid argument(s)");
interactive_tool=(struct Interactive_tool *)NULL;
}
LEAVE;
return (interactive_tool);
} /* Node_tool_get_interactive_tool */
#if defined (WX_USER_INTERFACE)
static int Node_tool_end_element_creation(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
DEACCESSes the element being created, if any, and if it is unmanaged, warns that
the creation was aborted. Also clears the node list.
Call this function whether element is successfully created or not.
==============================================================================*/
{
int return_code;
wxListBox *new_element_nodes_list_box;
ENTER(node_tool_end_element_creation);
if (node_tool)
{
if (node_tool->element)
{
if (!FE_region_contains_FE_element(node_tool->fe_region,
node_tool->element))
{
display_message(WARNING_MESSAGE,
"node_tool: destroying incomplete element");
}
DEACCESS(FE_element)(&(node_tool->element));
if (node_tool->wx_node_tool != NULL)
{
new_element_nodes_list_box = XRCCTRL(*node_tool->wx_node_tool, "NewElementNodesListBox", wxListBox);
new_element_nodes_list_box->Clear();
}
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_end_element_creation. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* Element_creator_end_element_creation */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
static int Node_tool_add_element(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Adds the just created element to the fe_region, adding faces as necessary.
==============================================================================*/
{
int return_code;
ENTER(node_tool_add_element);
if (node_tool && node_tool->fe_region && node_tool->element)
{
FE_region_begin_change(node_tool->fe_region);
FE_region_begin_define_faces(node_tool->fe_region);
return_code = FE_region_merge_FE_element_and_faces_and_nodes(
node_tool->fe_region, node_tool->element);
FE_region_end_define_faces(node_tool->fe_region);
FE_region_end_change(node_tool->fe_region);
Node_tool_end_element_creation(node_tool);
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_add_element. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* node_tool_add_element */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
static void Node_tool_node_selection_change(
struct FE_node_selection *node_selection,
struct FE_node_selection_changes *changes,void *node_tool_void)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Callback for change in the global node selection.
==============================================================================*/
{
char temp_string[50];
int number_of_nodes, number;
struct CM_element_information element_identifier;
struct Node_tool *node_tool;
struct FE_node *node;
wxString blank;
wxListBox *new_element_nodes_list_box;
struct FE_field *fe_field;
struct LIST(FE_field) *fe_field_list;
ENTER(node_tool_node_selection_change);
if (node_selection&&changes&&(node_tool=
(struct Node_tool *)node_tool_void))
{
/* if exactly 1 node selected, add it to element */
if (1==NUMBER_IN_LIST(FE_node)(changes->newly_selected_node_list))
{
/* get the last selected node and check it is in the FE_region */
node = FIRST_OBJECT_IN_LIST_THAT(FE_node)(
(LIST_CONDITIONAL_FUNCTION(FE_node) *)NULL,(void *)NULL,
changes->newly_selected_node_list);
if (FE_region_contains_FE_node(node_tool->fe_region, node))
{
if (!node_tool->element)
{
/* get next unused element identifier from fe_region */
element_identifier.type = CM_ELEMENT;
element_identifier.number = FE_region_get_next_FE_element_identifier(
node_tool->fe_region, CM_ELEMENT, 1);
if (node_tool->coordinate_field && (fe_field_list=
Computed_field_get_defining_FE_field_list(node_tool->coordinate_field)))
{
if ((1==NUMBER_IN_LIST(FE_field)(fe_field_list)) &&
(fe_field=FIRST_OBJECT_IN_LIST_THAT(FE_field)(
(LIST_CONDITIONAL_FUNCTION(FE_field) *)NULL,(void *)NULL,
fe_field_list)) &&
(3 >= get_FE_field_number_of_components(fe_field)) &&
(FE_VALUE_VALUE == get_FE_field_value_type(fe_field)))
{
if (node_tool->template_element ||
(((node_tool->template_element = create_FE_element_with_line_shape(
/*identifier*/1,node_tool->fe_region, node_tool->element_dimension)) &&
FE_element_define_tensor_product_basis(node_tool->template_element,
node_tool->element_dimension,/*basis_type*/LINEAR_LAGRANGE,
fe_field)) &&
ACCESS(FE_element)(node_tool->template_element)))
{
if (node_tool->element = CREATE(FE_element)(&element_identifier,
(struct FE_element_shape *)NULL, (struct FE_region *)NULL,
node_tool->template_element))
{
ACCESS(FE_element)(node_tool->element);
node_tool->number_of_clicked_nodes=0;
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not create element");
}
}
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not create template element");
}
}
if (node_tool->element)
{
/* When we make more than linear elements we will need
to check that the derivatives exist and are the correct ones */
if (set_FE_element_node(node_tool->element,
node_tool->number_of_clicked_nodes,node))
{
if (node_tool->wx_node_tool != NULL)
{
sprintf(temp_string,"%d. Node %d",
node_tool->number_of_clicked_nodes+1,
get_FE_node_identifier(node));
wxString string(temp_string, wxConvUTF8);
new_element_nodes_list_box = XRCCTRL(*node_tool->wx_node_tool, "NewElementNodesListBox", wxListBox);
number = new_element_nodes_list_box->GetCount();
if (number == 0)
{
new_element_nodes_list_box->InsertItems(1, &blank ,number);
}
number = new_element_nodes_list_box->GetCount();
new_element_nodes_list_box->InsertItems(1,&string, number-1);
}
node_tool->number_of_clicked_nodes++;
if (get_FE_element_number_of_nodes(node_tool->element,
&number_of_nodes) &&
(node_tool->number_of_clicked_nodes == number_of_nodes))
{
Node_tool_add_element(node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not set node");
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Could not create element");
}
}
else
{
display_message(ERROR_MESSAGE,
"Element creator: Selected node not from current region");
}
}
}
else
{
display_message(ERROR_MESSAGE,
"node_tool_node_selection_change. Invalid argument(s)");
}
LEAVE;
} /* node_tool_node_selection_change */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_create_enabled(struct Node_tool *node_tool ,
int element_create_enabled)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Sets flag controlling whether elements are created in response to
node selection.
==============================================================================*/
{
int return_code;
ENTER(node_tool_set_create_enabled);
if (node_tool )
{
/* make sure value of flag is 1 */
if (element_create_enabled)
{
element_create_enabled=1;
}
if (element_create_enabled != node_tool ->element_create_enabled)
{
node_tool ->element_create_enabled=element_create_enabled;
if (element_create_enabled)
{
/* request callbacks from the global node_selection */
FE_node_selection_add_callback(node_tool ->node_selection,
Node_tool_node_selection_change,
(void *)node_tool);
}
else
{
Node_tool_end_element_creation(node_tool);
/* end callbacks from the global node_selection */
FE_node_selection_remove_callback(node_tool->node_selection,
Node_tool_node_selection_change,
(void *)node_tool);
}
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,
"node_tool _set_create_enabled. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* node_tool _set_create_enabled */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_set_element_dimension(
struct Node_tool *node_tool,int element_dimension)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Sets the <element_dimension> of elements to be created by <node_tool>.
==============================================================================*/
{
int return_code;
ENTER(Node_tool_set_element_dimension);
if (node_tool)
{
if ((0<element_dimension)&&(element_dimension<=3))
{
return_code=1;
if (node_tool->element_dimension != element_dimension)
{
node_tool->element_dimension=element_dimension;
Node_tool_end_element_creation(node_tool);
/* lose the current template element and node, if any */
REACCESS(FE_element)(&(node_tool->template_element),
(struct FE_element *)NULL);
}
if (node_tool->wx_node_tool != NULL)
{
Node_tool_refresh_element_dimension_text(node_tool);
}
}
else
{
display_message(ERROR_MESSAGE,"Dimension must be from 1 to 3");
return_code=0;
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_set_element_dimension. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* node_tool_set_element_dimension */
#endif /* defined (WX_USER_INTERFACE)*/
# if defined (WX_USER_INTERFACE)
static int Node_tool_refresh_element_dimension_text(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 11 April 2007
DESCRIPTION :
Updates what is shown on the dimension text field.
==============================================================================*/
{
char temp_string[20],*value_string;
int return_code;
wxTextCtrl *dimension_textctrl;
dimension_textctrl = XRCCTRL(*node_tool->wx_node_tool, "DimensionTextCtrl", wxTextCtrl);
ENTER(Node_tool_refresh_element_dimension_text);
if (node_tool)
{
return_code=1;
if (value_string=const_cast<char *>((dimension_textctrl->GetValue()).c_str()))
{
sprintf(temp_string,"%d",node_tool->element_dimension);
/* only set string if different from that shown */
if (strcmp(temp_string,value_string))
{
wxString string(temp_string, wxConvUTF8);
dimension_textctrl->ChangeValue(string);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_refresh_element_dimension_text. Invalid argument(s)");
return_code=0;
}
LEAVE;
return (return_code);
} /* node_tool_refresh_element_dimension_text */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_get_element_create_enabled(struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 12 April 2007
DESCRIPTION :
Returns flag controlling whether node edits are updated during motion_notify
events, not just at the end of a mouse gesture.
==============================================================================*/
{
int element_create_enabled;
ENTER(Node_tool_get_element_create_enabled);
if (node_tool)
{
element_create_enabled=node_tool->element_create_enabled;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_element_create_enabled. Invalid argument(s)");
element_create_enabled=0;
}
LEAVE;
return (element_create_enabled);
} /* node_tool_get_create_enabled */
#endif /* defined (WX_USER_INTERFACE)*/
#if defined (WX_USER_INTERFACE)
int Node_tool_get_element_dimension(
struct Node_tool *node_tool)
/*******************************************************************************
LAST MODIFIED : 12 April 2007
DESCRIPTION :
Returns the dimension of elements to be created by the <node_tool>.
==============================================================================*/
{
int element_dimension;
ENTER(Node_tool_get_element_dimension);
if (node_tool)
{
element_dimension=node_tool->element_dimension;
}
else
{
display_message(ERROR_MESSAGE,
"Node_tool_get_element_dimension. Invalid argument(s)");
element_dimension=0;
}
LEAVE;
return (element_dimension);
} /* node_tool_get_element_dimension */
#endif /* defined (WX_USER_INTERFACE)*/
|
#ifndef VIENNAGRID_GEOMETRIC_DOMAIN_HPP
#define VIENNAGRID_GEOMETRIC_DOMAIN_HPP
/* =======================================================================
Copyright (c) 2011-2012, Institute for Microelectronics,
Institute for Analysis and Scientific Computing,
TU Wien.
-----------------
ViennaGrid - The Vienna Grid Library
-----------------
Authors: Karl Rupp rupp@iue.tuwien.ac.at
Josef Weinbub weinbub@iue.tuwien.ac.at
(A list of additional contributors can be found in the PDF manual)
License: MIT (X11), see file LICENSE in the base directory
======================================================================= */
#include "viennagrid/config/generic_config.hpp"
#include "viennagrid/domain/topologic_domain.hpp"
#include "viennagrid/domain/metainfo.hpp"
#include "viennagrid/element/element_view.hpp"
namespace viennagrid
{
struct topologic_config_tag;
struct vector_type_tag;
struct metainfo_typelist_tag;
struct metainfo_container_config_tag;
namespace result_of
{
template<typename domain_config>
struct topologic_config
{
typedef typename viennameta::typemap::result_of::find<domain_config, topologic_config_tag>::type::second type;
};
template<typename domain_config>
struct vector_type
{
typedef typename viennameta::typemap::result_of::find<domain_config, vector_type_tag>::type::second type;
};
template<typename domain_config>
struct metainfo_typelist
{
typedef typename viennameta::typemap::result_of::find<domain_config, metainfo_typelist_tag>::type::second type;
};
template<typename domain_config>
struct metainfo_container_config
{
typedef typename viennameta::typemap::result_of::find<domain_config, metainfo_container_config_tag>::type::second type;
};
}
template<typename vector_type_, typename topologic_domain_type_, typename metainfo_collection_type_>
class geometric_domain_t
{
typedef geometric_domain_t<vector_type_, topologic_domain_type_, metainfo_collection_type_> self_type;
public:
typedef vector_type_ vector_type;
typedef topologic_domain_type_ topologic_domain_type;
typedef metainfo_collection_type_ metainfo_collection_type;
geometric_domain_t() : topologic_domain(create_topologic_domain<topologic_domain_type>()) {}
// geometric_domain_t(topologic_domain_type topologic_domain_, metainfo_collection_type metainfo_collection_) :
// topologic_domain(topologic_domain_), metainfo_collection(metainfo_collection_) {}
/** @brief Constructor triggering the refinement of the domain */
template <typename CellTag, typename OtherDomainType, typename RefinementTag>
geometric_domain_t(refinement_proxy<CellTag, OtherDomainType, RefinementTag> const & proxy) : topologic_domain(create_topologic_domain<topologic_domain_type>())
{
detail::refine_impl<CellTag>(proxy.get(), *this, proxy.tag());
}
typedef typename result_of::element< self_type, viennagrid::vertex_tag >::type vertex_type;
typedef typename result_of::element_hook< self_type, viennagrid::vertex_tag >::type vertex_hook_type;
typedef typename result_of::const_element_hook< self_type, viennagrid::vertex_tag >::type const_vertex_hook_type;
topologic_domain_type & get_topological_domain() { return topologic_domain; }
const topologic_domain_type & get_topological_domain() const { return topologic_domain; }
metainfo_collection_type & get_metainfo_collection() { return metainfo_collection; }
const metainfo_collection_type & get_metainfo_collection() const { return metainfo_collection; }
private:
topologic_domain_type topologic_domain;
metainfo_collection_type metainfo_collection;
};
template<typename vector_type_, typename topologic_domain_type_, typename metainfo_collection_type_>
class geometric_domain_t<vector_type_, topologic_domain_type_, metainfo_collection_type_ *>
{
typedef geometric_domain_t<vector_type_, topologic_domain_type_, metainfo_collection_type_*> self_type;
public:
typedef vector_type_ vector_type;
typedef topologic_domain_type_ topologic_domain_type;
typedef metainfo_collection_type_ metainfo_collection_type;
geometric_domain_t() : metainfo_collection(0) {}
geometric_domain_t(topologic_domain_type topologic_domain_, metainfo_collection_type & metainfo_collection_) :
topologic_domain(topologic_domain_), metainfo_collection(&metainfo_collection_) {}
typedef typename result_of::element< self_type, viennagrid::vertex_tag >::type vertex_type;
typedef typename result_of::element_hook< self_type, viennagrid::vertex_tag >::type vertex_hook_type;
typedef typename result_of::const_element_hook< self_type, viennagrid::vertex_tag >::type const_vertex_hook_type;
topologic_domain_type & get_topological_domain() { return topologic_domain; }
const topologic_domain_type & get_topological_domain() const { return topologic_domain; }
metainfo_collection_type & get_metainfo_collection() { return *metainfo_collection; }
const metainfo_collection_type & get_metainfo_collection() const { return *metainfo_collection; }
private:
topologic_domain_type topologic_domain;
metainfo_collection_type * metainfo_collection;
};
namespace result_of
{
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct element< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename element<topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct element_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename element_hook<topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct const_element_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename const_element_hook<topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct element_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename element_range< topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct const_element_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename const_element_range< topologic_domain_type, element_type_or_tag>::type type;
};
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct ncell< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename ncell<topologic_domain_type, dim>::type type;
// };
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct ncell_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename ncell_hook<topologic_domain_type, dim>::type type;
// };
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct const_ncell_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename const_ncell_hook<topologic_domain_type, dim>::type type;
// };
//
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct ncell_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename ncell_range< topologic_domain_type, dim>::type type;
// };
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct const_ncell_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename const_ncell_range< topologic_domain_type, dim>::type type;
// };
}
template<typename element_type_or_tag, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::element_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag>::type elements(geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return elements<element_type_or_tag>( domain.get_topological_domain() );
}
template<typename element_type_or_tag, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::const_element_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag>::type elements(const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return elements<element_type_or_tag>( domain.get_topological_domain() );
}
template<long dim, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::ncell_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim>::type ncells(geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return ncells<dim>( domain.get_topological_domain() );
}
template<long dim, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::const_ncell_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim>::type ncells(const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return ncells<dim>( domain.get_topological_domain() );
}
namespace result_of
{
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct topologic_domain< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef topologic_domain_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef typename topologic_domain_type::container_collection_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct metainfo_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef metainfo_collection_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct metainfo_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type *> >
{
typedef metainfo_collection_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type, typename metainfo_type>
struct metainfo_container< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type, metainfo_type>
{
typedef typename metainfo_container<metainfo_collection_type, element_type, metainfo_type >::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type, typename metainfo_type>
struct const_metainfo_container< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type, metainfo_type>
{
typedef typename const_metainfo_container<metainfo_collection_type, element_type, metainfo_type >::type type;
};
template<typename point_container_type>
struct point_type
{
typedef typename viennagrid::metainfo::result_of::value_type<point_container_type>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct point_type< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >
{
typedef vector_type type;
};
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::topologic_domain< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & topologic_domain( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_topological_domain(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename result_of::topologic_domain< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & topologic_domain( const geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_topological_domain(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & metainfo_collection( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_metainfo_collection(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & metainfo_collection( const geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_metainfo_collection(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > >::type & metainfo_collection( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > & domain )
{ return domain.get_metainfo_collection(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > >::type & metainfo_collection( const geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > & domain )
{ return domain.get_metainfo_collection(); }
template<typename metainfo_collection_type>
metainfo_collection_type & metainfo_collection( metainfo_collection_type & collection )
{ return collection; }
template<typename metainfo_collection_type>
const metainfo_collection_type & metainfo_collection( const metainfo_collection_type & collection )
{ return collection; }
template<typename element_type, typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_container< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type >, element_type, metainfo_type>::type &
metainfo_container( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{
return metainfo_container<element_type, metainfo_type>( metainfo_collection(domain) );
}
template<typename element_type, typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_container< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type >, element_type, metainfo_type>::type const &
metainfo_container( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > const & domain )
{
return metainfo_container<element_type, metainfo_type>( metainfo_collection(domain) );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
metainfo_type & look_up( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_t<element_tag, boundary_cell_container_typelist, id_type> & element )
{
return look_up<metainfo_type>( metainfo_collection(domain), element );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
const metainfo_type & look_up( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_t<element_tag, boundary_cell_container_typelist, id_type> & element )
{
return look_up<metainfo_type>( metainfo_collection(domain), element );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_hook_type>
metainfo_type & look_up( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_hook_type & element_hook )
{
return look_up<metainfo_type>( metainfo_collection(domain), dereference_hook(domain, element_hook) );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_hook_type>
const metainfo_type & look_up( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_hook_type & element_hook )
{
return look_up<metainfo_type>( metainfo_collection(domain), dereference_hook(domain, element_hook) );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type, typename metainfo_type>
void set( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_type & element, const metainfo_type & meta_info )
{
metainfo::set( metainfo_container<element_type, metainfo_type>(domain.get_metainfo_collection()), element, meta_info );
}
template<typename container_type, typename vertex_type>
typename container_type::value_type & point( container_type & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename container_type, typename vertex_type>
const typename container_type::value_type & point( container_type const & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename id_type, typename vector_type, typename vertex_type>
vector_type & point( std::map<id_type, vector_type> & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename id_type, typename vector_type, typename vertex_type>
const vector_type & point( std::map<id_type, vector_type> const & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_type & vertex )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, vertex );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_type & vertex )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, vertex );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_hook_type & vertex_hook )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, dereference_hook(geometric_domain, vertex_hook) );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_hook_type & vertex_hook )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, dereference_hook(geometric_domain, vertex_hook) );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
std::pair<
typename viennagrid::storage::result_of::container_of<
typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type>
>::type::hook_type,
bool
>
push_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> & element)
{
metainfo::increment_size< viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> >(metainfo_collection(domain));
return inserter(domain)(element);
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type>
std::pair<
typename viennagrid::storage::result_of::container_of<
typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
element_type
>::type::hook_type,
bool
>
push_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_type & element)
{
metainfo::increment_size< element_type >(metainfo_collection(domain));
return inserter(domain)(element);
}
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
// std::pair<
// typename viennagrid::storage::result_of::container_of<
// typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
// viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type>
// >::type::hook_type,
// bool
// >
// push_element_noid( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> & element)
// {
// metainfo::increment_size< viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> >(metainfo_collection(domain));
// return inserter(domain).insert_noid(element);
// }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type>
std::pair<
typename viennagrid::storage::result_of::container_of<
typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
element_type
>::type::hook_type,
bool
>
push_element_noid( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_type & element)
{
metainfo::increment_size< element_type >(metainfo_collection(domain));
return inserter(domain).insert_noid(element);
}
template<typename element_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type
create_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const vector_type & point )
{
//typedef typename result_of::element<domain_type, viennagrid::vertex_tag>::type vertex_type;
//element_type element;
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type ret = push_element(domain, element_type() ).first;
viennagrid::point(domain, ret) = point;
return ret;
}
template<typename element_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type
create_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, typename element_type::id_type id, const vector_type & point )
{
//typedef typename result_of::element<domain_type, viennagrid::vertex_tag>::type vertex_type;
element_type element;
element.id( id );
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type ret = push_element_noid(domain, element_type() ).first;
viennagrid::point(domain, ret) = point;
return ret;
}
// template<typename domain_config>
// typename geometric_domain_t<domain_config>::vector_type & point( geometric_domain_t<domain_config> & geometric_domain, std::size_t pos )
// {
// return viennagrid::look_up<typename geometric_domain_t<domain_config>::vector_type>( geometric_domain, viennagrid::elements<viennagrid::vertex_tag>( geometric_domain )[pos] );
// }
//
// template<typename domain_config>
// const typename geometric_domain_t<domain_config>::vector_type & point( const geometric_domain_t<domain_config> & geometric_domain, std::size_t pos )
// {
// return viennagrid::look_up<typename geometric_domain_t<domain_config>::vector_type>( geometric_domain, viennagrid::elements<viennagrid::vertex_tag>( geometric_domain )[pos] );
// }
namespace result_of
{
template<typename element_tag, typename vector_type, typename hook_tag = viennagrid::storage::pointer_hook_tag,
typename metainfo_typelist = viennameta::null_type, typename metainfo_container_config = viennagrid::storage::default_container_config>
struct geometric_domain_config
{
typedef typename viennagrid::result_of::default_topologic_config<element_tag, hook_tag>::type toplologic_config;
typedef typename viennameta::make_typemap<
viennagrid::topologic_config_tag, toplologic_config,
viennagrid::vector_type_tag, vector_type,
viennagrid::metainfo_typelist_tag, metainfo_typelist,
viennagrid::metainfo_container_config_tag, metainfo_container_config
>::type type;
};
template<typename geometric_domain_config>
struct geometric_domain
{
typedef typename viennagrid::result_of::topologic_domain<
typename result_of::topologic_config<geometric_domain_config>::type
>::type topologic_domain_type;
typedef typename result_of::vector_type<geometric_domain_config>::type vector_type;
typedef typename viennagrid::storage::collection_t<
typename viennagrid::result_of::metainfo_container_typemap<
typename viennameta::typelist::result_of::push_back<
typename result_of::metainfo_typelist< geometric_domain_config >::type,
viennameta::static_pair<
viennagrid::vertex_tag,
vector_type
>
>::type,
typename result_of::metainfo_container_config<geometric_domain_config>::type,
typename result_of::topologic_config<geometric_domain_config>::type
>::type
> metainfo_collection_type;
typedef geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> type;
};
template<
typename geometric_domain_type,
typename element_typelist =
typename storage::container_collection::result_of::value_typelist<
typename container_collection<geometric_domain_type>::type
>::type,
typename container_config =
storage::default_container_config>
struct geometric_view
{
typedef typename viennagrid::result_of::topologic_view<typename geometric_domain_type::topologic_domain_type, element_typelist>::type topologic_view_type;
typedef typename geometric_domain_type::metainfo_collection_type metainfo_collection_type;
typedef typename viennagrid::geometric_domain_t<typename geometric_domain_type::vector_type, topologic_view_type, metainfo_collection_type*> type;
};
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct create_view_helper< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> geomatric_view_type;
template<typename domain_type>
static geomatric_view_type create( domain_type & domain )
{
typedef typename geomatric_view_type::topologic_domain_type topologic_view_type;
return geomatric_view_type(
viennagrid::create_view<topologic_view_type>( viennagrid::topologic_domain(domain) ),
domain.get_metainfo_collection()
);
}
};
template<typename domain_type, typename id_type>
typename viennagrid::result_of::hook_iterator< typename viennagrid::result_of::element_range<domain_type, typename id_type::value_type::tag>::type >::type
find_hook(domain_type & domain, id_type id)
{
typedef typename id_type::value_type element_type;
typedef typename element_type::tag element_tag;
typedef typename viennagrid::result_of::element_range<domain_type, element_tag>::type RangeType;
typedef typename viennagrid::result_of::hook_iterator<RangeType>::type RangeIterator;
RangeType range = viennagrid::elements<element_tag>(domain);
for (RangeIterator it = range.hook_begin(); it != range.hook_end(); ++it)
{
if ( viennagrid::dereference_hook(domain, *it).id() == id )
return it;
}
return range.hook_end();
//return typename result_of::element_hook<domain_type, element_tag>::type();
//return storage::hook::invalid_hook( range );
}
template<typename domain_type, typename id_type>
typename viennagrid::result_of::const_hook_iterator< typename viennagrid::result_of::const_element_range<domain_type, typename id_type::value_type::tag>::type >::type
find_hook(const domain_type & domain, id_type id)
{
typedef typename id_type::value_type element_type;
typedef typename element_type::tag element_tag;
typedef typename viennagrid::result_of::const_element_range<domain_type, element_tag>::type RangeType;
typedef typename viennagrid::result_of::const_hook_iterator<RangeType>::type RangeIterator;
RangeType range = viennagrid::elements<element_tag>(domain);
for (RangeIterator it = range.hook_begin(); it != range.hook_end(); ++it)
{
if ( viennagrid::dereference_hook(domain, *it).id() == id )
return it;
}
return range.hook_end();
//return typename result_of::const_element_hook<domain_type, element_tag>::type();
//return storage::hook::invalid_hook( range );
}
}
#endif
adapted to new inserter interface
fixed typo
#ifndef VIENNAGRID_GEOMETRIC_DOMAIN_HPP
#define VIENNAGRID_GEOMETRIC_DOMAIN_HPP
/* =======================================================================
Copyright (c) 2011-2012, Institute for Microelectronics,
Institute for Analysis and Scientific Computing,
TU Wien.
-----------------
ViennaGrid - The Vienna Grid Library
-----------------
Authors: Karl Rupp rupp@iue.tuwien.ac.at
Josef Weinbub weinbub@iue.tuwien.ac.at
(A list of additional contributors can be found in the PDF manual)
License: MIT (X11), see file LICENSE in the base directory
======================================================================= */
#include "viennagrid/config/generic_config.hpp"
#include "viennagrid/domain/topologic_domain.hpp"
#include "viennagrid/domain/metainfo.hpp"
#include "viennagrid/element/element_view.hpp"
namespace viennagrid
{
struct topologic_config_tag;
struct vector_type_tag;
struct metainfo_typelist_tag;
struct metainfo_container_config_tag;
namespace result_of
{
template<typename domain_config>
struct topologic_config
{
typedef typename viennameta::typemap::result_of::find<domain_config, topologic_config_tag>::type::second type;
};
template<typename domain_config>
struct vector_type
{
typedef typename viennameta::typemap::result_of::find<domain_config, vector_type_tag>::type::second type;
};
template<typename domain_config>
struct metainfo_typelist
{
typedef typename viennameta::typemap::result_of::find<domain_config, metainfo_typelist_tag>::type::second type;
};
template<typename domain_config>
struct metainfo_container_config
{
typedef typename viennameta::typemap::result_of::find<domain_config, metainfo_container_config_tag>::type::second type;
};
}
template<typename vector_type_, typename topologic_domain_type_, typename metainfo_collection_type_>
class geometric_domain_t
{
typedef geometric_domain_t<vector_type_, topologic_domain_type_, metainfo_collection_type_> self_type;
public:
typedef vector_type_ vector_type;
typedef topologic_domain_type_ topologic_domain_type;
typedef metainfo_collection_type_ metainfo_collection_type;
geometric_domain_t() : topologic_domain(create_topologic_domain<topologic_domain_type>()) {}
// geometric_domain_t(topologic_domain_type topologic_domain_, metainfo_collection_type metainfo_collection_) :
// topologic_domain(topologic_domain_), metainfo_collection(metainfo_collection_) {}
/** @brief Constructor triggering the refinement of the domain */
template <typename CellTag, typename OtherDomainType, typename RefinementTag>
geometric_domain_t(refinement_proxy<CellTag, OtherDomainType, RefinementTag> const & proxy) : topologic_domain(create_topologic_domain<topologic_domain_type>())
{
detail::refine_impl<CellTag>(proxy.get(), *this, proxy.tag());
}
typedef typename result_of::element< self_type, viennagrid::vertex_tag >::type vertex_type;
typedef typename result_of::element_hook< self_type, viennagrid::vertex_tag >::type vertex_hook_type;
typedef typename result_of::const_element_hook< self_type, viennagrid::vertex_tag >::type const_vertex_hook_type;
topologic_domain_type & get_topological_domain() { return topologic_domain; }
const topologic_domain_type & get_topological_domain() const { return topologic_domain; }
metainfo_collection_type & get_metainfo_collection() { return metainfo_collection; }
const metainfo_collection_type & get_metainfo_collection() const { return metainfo_collection; }
private:
topologic_domain_type topologic_domain;
metainfo_collection_type metainfo_collection;
};
template<typename vector_type_, typename topologic_domain_type_, typename metainfo_collection_type_>
class geometric_domain_t<vector_type_, topologic_domain_type_, metainfo_collection_type_ *>
{
typedef geometric_domain_t<vector_type_, topologic_domain_type_, metainfo_collection_type_*> self_type;
public:
typedef vector_type_ vector_type;
typedef topologic_domain_type_ topologic_domain_type;
typedef metainfo_collection_type_ metainfo_collection_type;
geometric_domain_t() : metainfo_collection(0) {}
geometric_domain_t(topologic_domain_type topologic_domain_, metainfo_collection_type & metainfo_collection_) :
topologic_domain(topologic_domain_), metainfo_collection(&metainfo_collection_) {}
typedef typename result_of::element< self_type, viennagrid::vertex_tag >::type vertex_type;
typedef typename result_of::element_hook< self_type, viennagrid::vertex_tag >::type vertex_hook_type;
typedef typename result_of::const_element_hook< self_type, viennagrid::vertex_tag >::type const_vertex_hook_type;
topologic_domain_type & get_topological_domain() { return topologic_domain; }
const topologic_domain_type & get_topological_domain() const { return topologic_domain; }
metainfo_collection_type & get_metainfo_collection() { return *metainfo_collection; }
const metainfo_collection_type & get_metainfo_collection() const { return *metainfo_collection; }
private:
topologic_domain_type topologic_domain;
metainfo_collection_type * metainfo_collection;
};
namespace result_of
{
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct element< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename element<topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct element_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename element_hook<topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct const_element_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename const_element_hook<topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct element_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename element_range< topologic_domain_type, element_type_or_tag>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type_or_tag>
struct const_element_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag >
{
typedef typename const_element_range< topologic_domain_type, element_type_or_tag>::type type;
};
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct ncell< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename ncell<topologic_domain_type, dim>::type type;
// };
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct ncell_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename ncell_hook<topologic_domain_type, dim>::type type;
// };
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct const_ncell_hook< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename const_ncell_hook<topologic_domain_type, dim>::type type;
// };
//
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct ncell_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename ncell_range< topologic_domain_type, dim>::type type;
// };
//
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, long dim>
// struct const_ncell_range< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim >
// {
// typedef typename const_ncell_range< topologic_domain_type, dim>::type type;
// };
}
template<typename element_type_or_tag, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::element_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag>::type elements(geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return elements<element_type_or_tag>( domain.get_topological_domain() );
}
template<typename element_type_or_tag, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::const_element_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type_or_tag>::type elements(const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return elements<element_type_or_tag>( domain.get_topological_domain() );
}
template<long dim, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::ncell_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim>::type ncells(geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return ncells<dim>( domain.get_topological_domain() );
}
template<long dim, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::const_ncell_range<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, dim>::type ncells(const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain)
{
return ncells<dim>( domain.get_topological_domain() );
}
namespace result_of
{
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct topologic_domain< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef topologic_domain_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef typename topologic_domain_type::container_collection_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct metainfo_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef metainfo_collection_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct metainfo_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type *> >
{
typedef metainfo_collection_type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type, typename metainfo_type>
struct metainfo_container< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type, metainfo_type>
{
typedef typename metainfo_container<metainfo_collection_type, element_type, metainfo_type >::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type, typename metainfo_type>
struct const_metainfo_container< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type, metainfo_type>
{
typedef typename const_metainfo_container<metainfo_collection_type, element_type, metainfo_type >::type type;
};
template<typename point_container_type>
struct point_type
{
typedef typename viennagrid::metainfo::result_of::value_type<point_container_type>::type type;
};
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct point_type< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >
{
typedef vector_type type;
};
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::topologic_domain< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & topologic_domain( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_topological_domain(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename result_of::topologic_domain< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & topologic_domain( const geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_topological_domain(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & metainfo_collection( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_metainfo_collection(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > >::type & metainfo_collection( const geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{ return domain.get_metainfo_collection(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > >::type & metainfo_collection( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > & domain )
{ return domain.get_metainfo_collection(); }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename result_of::metainfo_collection< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > >::type & metainfo_collection( const geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type* > & domain )
{ return domain.get_metainfo_collection(); }
template<typename metainfo_collection_type>
metainfo_collection_type & metainfo_collection( metainfo_collection_type & collection )
{ return collection; }
template<typename metainfo_collection_type>
const metainfo_collection_type & metainfo_collection( const metainfo_collection_type & collection )
{ return collection; }
template<typename element_type, typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_container< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type >, element_type, metainfo_type>::type &
metainfo_container( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > & domain )
{
return metainfo_container<element_type, metainfo_type>( metainfo_collection(domain) );
}
template<typename element_type, typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::metainfo_container< geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type >, element_type, metainfo_type>::type const &
metainfo_container( geometric_domain_t< vector_type, topologic_domain_type, metainfo_collection_type > const & domain )
{
return metainfo_container<element_type, metainfo_type>( metainfo_collection(domain) );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
metainfo_type & look_up( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_t<element_tag, boundary_cell_container_typelist, id_type> & element )
{
return look_up<metainfo_type>( metainfo_collection(domain), element );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
const metainfo_type & look_up( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_t<element_tag, boundary_cell_container_typelist, id_type> & element )
{
return look_up<metainfo_type>( metainfo_collection(domain), element );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_hook_type>
metainfo_type & look_up( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_hook_type & element_hook )
{
return look_up<metainfo_type>( metainfo_collection(domain), dereference_hook(domain, element_hook) );
}
template<typename metainfo_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_hook_type>
const metainfo_type & look_up( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_hook_type & element_hook )
{
return look_up<metainfo_type>( metainfo_collection(domain), dereference_hook(domain, element_hook) );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type, typename metainfo_type>
void set( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_type & element, const metainfo_type & meta_info )
{
metainfo::set( metainfo_container<element_type, metainfo_type>(domain.get_metainfo_collection()), element, meta_info );
}
template<typename container_type, typename vertex_type>
typename container_type::value_type & point( container_type & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename container_type, typename vertex_type>
const typename container_type::value_type & point( container_type const & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename id_type, typename vector_type, typename vertex_type>
vector_type & point( std::map<id_type, vector_type> & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename id_type, typename vector_type, typename vertex_type>
const vector_type & point( std::map<id_type, vector_type> const & geometric_container, vertex_type const & vertex )
{
return viennagrid::metainfo::look_up( geometric_container, vertex );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_type & vertex )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, vertex );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_type & vertex )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, vertex );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_hook_type & vertex_hook )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, dereference_hook(geometric_domain, vertex_hook) );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type & point( const geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & geometric_domain, const typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vertex_hook_type & vertex_hook )
{
return viennagrid::look_up<typename geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>::vector_type>( geometric_domain, dereference_hook(geometric_domain, vertex_hook) );
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
std::pair<
typename viennagrid::storage::result_of::container_of<
typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type>
>::type::hook_type,
bool
>
push_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> & element)
{
metainfo::increment_size< viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> >(metainfo_collection(domain));
return inserter(domain)(element);
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type>
std::pair<
typename viennagrid::storage::result_of::container_of<
typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
element_type
>::type::hook_type,
bool
>
push_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_type & element)
{
metainfo::increment_size< element_type >(metainfo_collection(domain));
return inserter(domain)(element);
}
// template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_tag, typename boundary_cell_container_typelist, typename id_type>
// std::pair<
// typename viennagrid::storage::result_of::container_of<
// typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
// viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type>
// >::type::hook_type,
// bool
// >
// push_element_noid( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> & element)
// {
// metainfo::increment_size< viennagrid::element_t<element_tag, boundary_cell_container_typelist, id_type> >(metainfo_collection(domain));
// return inserter(domain).insert_noid(element);
// }
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type, typename element_type>
std::pair<
typename viennagrid::storage::result_of::container_of<
typename result_of::container_collection< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >::type,
element_type
>::type::hook_type,
bool
>
push_element_noid( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const element_type & element)
{
metainfo::increment_size< element_type >(metainfo_collection(domain));
return inserter(domain).template insert<false, true>(element);
}
template<typename element_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type
create_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, const vector_type & point )
{
//typedef typename result_of::element<domain_type, viennagrid::vertex_tag>::type vertex_type;
//element_type element;
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type ret = push_element(domain, element_type() ).first;
viennagrid::point(domain, ret) = point;
return ret;
}
template<typename element_type, typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type
create_element( geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> & domain, typename element_type::id_type id, const vector_type & point )
{
//typedef typename result_of::element<domain_type, viennagrid::vertex_tag>::type vertex_type;
element_type element;
element.id( id );
typename result_of::element_hook<geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type>, element_type>::type ret = push_element_noid(domain, element_type() ).first;
viennagrid::point(domain, ret) = point;
return ret;
}
// template<typename domain_config>
// typename geometric_domain_t<domain_config>::vector_type & point( geometric_domain_t<domain_config> & geometric_domain, std::size_t pos )
// {
// return viennagrid::look_up<typename geometric_domain_t<domain_config>::vector_type>( geometric_domain, viennagrid::elements<viennagrid::vertex_tag>( geometric_domain )[pos] );
// }
//
// template<typename domain_config>
// const typename geometric_domain_t<domain_config>::vector_type & point( const geometric_domain_t<domain_config> & geometric_domain, std::size_t pos )
// {
// return viennagrid::look_up<typename geometric_domain_t<domain_config>::vector_type>( geometric_domain, viennagrid::elements<viennagrid::vertex_tag>( geometric_domain )[pos] );
// }
namespace result_of
{
template<typename element_tag, typename vector_type, typename hook_tag = viennagrid::storage::pointer_hook_tag,
typename metainfo_typelist = viennameta::null_type, typename metainfo_container_config = viennagrid::storage::default_container_config>
struct geometric_domain_config
{
typedef typename viennagrid::result_of::default_topologic_config<element_tag, hook_tag>::type topologic_config;
typedef typename viennameta::make_typemap<
viennagrid::topologic_config_tag, topologic_config,
viennagrid::vector_type_tag, vector_type,
viennagrid::metainfo_typelist_tag, metainfo_typelist,
viennagrid::metainfo_container_config_tag, metainfo_container_config
>::type type;
};
template<typename geometric_domain_config>
struct geometric_domain
{
typedef typename viennagrid::result_of::topologic_domain<
typename result_of::topologic_config<geometric_domain_config>::type
>::type topologic_domain_type;
typedef typename result_of::vector_type<geometric_domain_config>::type vector_type;
typedef typename viennagrid::storage::collection_t<
typename viennagrid::result_of::metainfo_container_typemap<
typename viennameta::typelist::result_of::push_back<
typename result_of::metainfo_typelist< geometric_domain_config >::type,
viennameta::static_pair<
viennagrid::vertex_tag,
vector_type
>
>::type,
typename result_of::metainfo_container_config<geometric_domain_config>::type,
typename result_of::topologic_config<geometric_domain_config>::type
>::type
> metainfo_collection_type;
typedef geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> type;
};
template<
typename geometric_domain_type,
typename element_typelist =
typename storage::container_collection::result_of::value_typelist<
typename container_collection<geometric_domain_type>::type
>::type,
typename container_config =
storage::default_container_config>
struct geometric_view
{
typedef typename viennagrid::result_of::topologic_view<typename geometric_domain_type::topologic_domain_type, element_typelist>::type topologic_view_type;
typedef typename geometric_domain_type::metainfo_collection_type metainfo_collection_type;
typedef typename viennagrid::geometric_domain_t<typename geometric_domain_type::vector_type, topologic_view_type, metainfo_collection_type*> type;
};
}
template<typename vector_type, typename topologic_domain_type, typename metainfo_collection_type>
struct create_view_helper< geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> >
{
typedef geometric_domain_t<vector_type, topologic_domain_type, metainfo_collection_type> geomatric_view_type;
template<typename domain_type>
static geomatric_view_type create( domain_type & domain )
{
typedef typename geomatric_view_type::topologic_domain_type topologic_view_type;
return geomatric_view_type(
viennagrid::create_view<topologic_view_type>( viennagrid::topologic_domain(domain) ),
domain.get_metainfo_collection()
);
}
};
template<typename domain_type, typename id_type>
typename viennagrid::result_of::hook_iterator< typename viennagrid::result_of::element_range<domain_type, typename id_type::value_type::tag>::type >::type
find_hook(domain_type & domain, id_type id)
{
typedef typename id_type::value_type element_type;
typedef typename element_type::tag element_tag;
typedef typename viennagrid::result_of::element_range<domain_type, element_tag>::type RangeType;
typedef typename viennagrid::result_of::hook_iterator<RangeType>::type RangeIterator;
RangeType range = viennagrid::elements<element_tag>(domain);
for (RangeIterator it = range.hook_begin(); it != range.hook_end(); ++it)
{
if ( viennagrid::dereference_hook(domain, *it).id() == id )
return it;
}
return range.hook_end();
//return typename result_of::element_hook<domain_type, element_tag>::type();
//return storage::hook::invalid_hook( range );
}
template<typename domain_type, typename id_type>
typename viennagrid::result_of::const_hook_iterator< typename viennagrid::result_of::const_element_range<domain_type, typename id_type::value_type::tag>::type >::type
find_hook(const domain_type & domain, id_type id)
{
typedef typename id_type::value_type element_type;
typedef typename element_type::tag element_tag;
typedef typename viennagrid::result_of::const_element_range<domain_type, element_tag>::type RangeType;
typedef typename viennagrid::result_of::const_hook_iterator<RangeType>::type RangeIterator;
RangeType range = viennagrid::elements<element_tag>(domain);
for (RangeIterator it = range.hook_begin(); it != range.hook_end(); ++it)
{
if ( viennagrid::dereference_hook(domain, *it).id() == id )
return it;
}
return range.hook_end();
//return typename result_of::const_element_hook<domain_type, element_tag>::type();
//return storage::hook::invalid_hook( range );
}
}
#endif
|
#include "testsettings.hpp"
#ifdef TEST_GROUP
#include <algorithm>
#include <fstream>
#include <sys/stat.h>
// File permissions for Windows
// http://stackoverflow.com/questions/592448/c-how-to-set-file-permissions-cross-platform
#ifdef _WIN32
#include <io.h>
typedef int mode_t;
static const mode_t S_IWUSR = mode_t(_S_IWRITE);
static const mode_t MS_MODE_MASK = 0x0000ffff;
#endif
#include <UnitTest++.h>
#include <tightdb.hpp>
#include <tightdb/util/file.hpp>
using namespace std;
using namespace tightdb;
using namespace tightdb::util;
// Note: You can now temporarely declare unit tests with the ONLY(TestName) macro instead of TEST(TestName). This
// will disable all unit tests except these. Remember to undo your temporary changes before committing.
namespace {
enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
TIGHTDB_TABLE_4(TestTableGroup,
first, String,
second, Int,
third, Bool,
fourth, Enum<Days>)
} // Anonymous namespace
TEST(Group_Unattached)
{
Group group((Group::unattached_tag()));
CHECK(!group.is_attached());
}
TEST(Group_OpenFile)
{
File::try_remove("test.tightdb");
{
Group group((Group::unattached_tag()));
group.open("test.tightdb", Group::mode_ReadWrite);
CHECK(group.is_attached());
}
{
Group group((Group::unattached_tag()));
group.open("test.tightdb", Group::mode_ReadWriteNoCreate);
CHECK(group.is_attached());
}
{
Group group((Group::unattached_tag()));
group.open("test.tightdb", Group::mode_ReadOnly);
CHECK(group.is_attached());
}
File::remove("test.tightdb");
}
TEST(Group_Permissions)
{
util::File::try_remove("test.tightdb");
{
Group group1;
TableRef t1 = group1.get_table("table1");
t1->add_column(type_String, "s");
t1->add_column(type_Int, "i");
for(size_t i=0; i<4; ++i) {
t1->insert_string(0, i, "a");
t1->insert_int(1, i, 3);
t1->insert_done();
}
group1.write("test.tightdb");
}
#ifdef _WIN32
_chmod("test.tightdb", S_IWUSR & MS_MODE_MASK);
#else
chmod("test.tightdb", S_IWUSR);
#endif
{
Group group2((Group::unattached_tag()));
CHECK_THROW(group2.open("test.tightdb", Group::mode_ReadOnly), util::File::PermissionDenied);
CHECK(!group2.has_table("table1")); // is not attached
}
util::File::try_remove("test.tightdb");
}
TEST(Group_BadFile)
{
File::try_remove("test.tightdb");
File::try_remove("test2.tightdb");
{
File file("test.tightdb", File::mode_Append);
file.write("foo");
}
{
Group group((Group::unattached_tag()));
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadOnly), InvalidDatabase);
CHECK(!group.is_attached());
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadOnly), InvalidDatabase); // Again
CHECK(!group.is_attached());
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadWrite), InvalidDatabase);
CHECK(!group.is_attached());
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadWriteNoCreate), InvalidDatabase);
CHECK(!group.is_attached());
group.open("test2.tightdb", Group::mode_ReadWrite); // This one must work
CHECK(group.is_attached());
}
File::remove("test.tightdb");
File::remove("test2.tightdb");
}
TEST(Group_OpenBuffer)
{
// Produce a valid buffer
UniquePtr<char[]> buffer;
size_t buffer_size;
{
File::try_remove("test.tightdb");
{
Group group;
group.write("test.tightdb");
}
{
File file("test.tightdb");
buffer_size = size_t(file.get_size());
buffer.reset(static_cast<char*>(malloc(buffer_size)));
CHECK(bool(buffer));
file.read(buffer.get(), buffer_size);
}
File::remove("test.tightdb");
}
// Keep ownership of buffer
{
Group group((Group::unattached_tag()));
bool take_ownership = false;
group.open(BinaryData(buffer.get(), buffer_size), take_ownership);
CHECK(group.is_attached());
}
// Pass ownership of buffer
{
Group group((Group::unattached_tag()));
bool take_ownership = true;
group.open(BinaryData(buffer.get(), buffer_size), take_ownership);
CHECK(group.is_attached());
buffer.release();
}
}
TEST(Group_BadBuffer)
{
File::try_remove("test.tightdb");
// Produce an invalid buffer
char buffer[32];
for (size_t i=0; i<sizeof buffer; ++i)
buffer[i] = char((i+192)%128);
{
Group group((Group::unattached_tag()));
bool take_ownership = false;
CHECK_THROW(group.open(BinaryData(buffer), take_ownership), InvalidDatabase);
CHECK(!group.is_attached());
// Check that ownership is not passed on failure during
// open. If it was, we would get a bad delete on stack
// allocated memory wich would at least be caught by Valgrind.
take_ownership = true;
CHECK_THROW(group.open(BinaryData(buffer), take_ownership), InvalidDatabase);
CHECK(!group.is_attached());
// Check that the group is still able to attach to a file,
// even after failures.
group.open("test.tightdb", Group::mode_ReadWrite);
CHECK(group.is_attached());
}
File::remove("test.tightdb");
}
TEST(Group_Size)
{
Group g;
CHECK(g.is_attached());
CHECK(g.is_empty());
TableRef t = g.get_table("a");
CHECK(!g.is_empty());
CHECK_EQUAL(1, g.size());
TableRef t1 = g.get_table("b");
CHECK(!g.is_empty());
CHECK_EQUAL(2, g.size());
}
TEST(Group_GetTable)
{
Group g;
const Group& cg = g;
TableRef t1 = g.get_table("alpha");
ConstTableRef t2 = cg.get_table("alpha");
CHECK_EQUAL(t1, t2);
TestTableGroup::Ref t3 = g.get_table<TestTableGroup>("beta");
TestTableGroup::ConstRef t4 = cg.get_table<TestTableGroup>("beta");
CHECK_EQUAL(t3, t4);
}
TEST(Group_GetTableWasCreated)
{
Group group;
bool was_created = false;
group.get_table("foo", was_created);
CHECK(was_created);
group.get_table("foo", was_created);
CHECK(!was_created);
group.get_table("bar", was_created);
CHECK(was_created);
group.get_table("baz", was_created);
CHECK(was_created);
group.get_table("bar", was_created);
CHECK(!was_created);
group.get_table("baz", was_created);
CHECK(!was_created);
}
namespace {
void setup_table(TestTableGroup::Ref t)
{
t->add("a", 1, true, Wed);
t->add("b", 15, true, Wed);
t->add("ccc", 10, true, Wed);
t->add("dddd", 20, true, Wed);
}
}
TEST(Group_Equal)
{
Group g1, g2;
TestTableGroup::Ref t1 = g1.get_table<TestTableGroup>("TABLE1");
setup_table(t1);
TestTableGroup::Ref t2 = g2.get_table<TestTableGroup>("TABLE1");
setup_table(t2);
CHECK_EQUAL(true, g1 == g2);
t2->add("hey", 2, false, Thu);
CHECK_EQUAL(true, g1 != g2);
}
TEST(Group_TableAccessorLeftBehind)
{
TableRef table;
TableRef subtable;
{
Group group;
table = group.get_table("test");
CHECK(table->is_attached());
table->add_column(type_Table, "sub");
table->add_empty_row();
subtable = table->get_subtable(0,0);
CHECK(subtable->is_attached());
}
CHECK(!table->is_attached());
CHECK(!subtable->is_attached());
}
TEST(Group_Invalid1)
{
File::try_remove("table_test.tightdb");
// Try to open non-existing file
// (read-only files have to exists to before opening)
CHECK_THROW(Group("table_test.tightdb"), File::NotFound);
}
TEST(Group_Invalid2)
{
// Try to open buffer with invalid data
const char* const str = "invalid data";
const size_t size = strlen(str);
char* const data = new char[strlen(str)];
copy(str, str+size, data);
CHECK_THROW(Group(BinaryData(data, size)), InvalidDatabase);
delete[] data;
}
TEST(Group_Overwrite)
{
File::try_remove("test_overwrite.tightdb");
{
Group g;
g.write("test_overwrite.tightdb");
CHECK_THROW(g.write("test_overwrite.tightdb"), File::Exists);
}
{
Group g("test_overwrite.tightdb");
CHECK_THROW(g.write("test_overwrite.tightdb"), File::Exists);
}
{
Group g;
File::try_remove("test_overwrite.tightdb");
g.write("test_overwrite.tightdb");
}
}
TEST(Group_Serialize0)
{
File::try_remove("table_test.tightdb");
// Create empty group and serialize to disk
Group to_disk;
to_disk.write("table_test.tightdb");
// Load the group
Group from_disk("table_test.tightdb");
// Create new table in group
TestTableGroup::Ref t = from_disk.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(0, t->size());
// Modify table
t->add("Test", 1, true, Wed);
CHECK_EQUAL("Test", t[0].first);
CHECK_EQUAL(1, t[0].second);
CHECK_EQUAL(true, t[0].third);
CHECK_EQUAL(Wed, t[0].fourth);
}
TEST(Group_Read0)
{
// Load the group and let it clean up without loading
// any tables
Group g("table_test.tightdb");
}
TEST(Group_Serialize1)
{
// Create group with one table
Group to_disk;
TestTableGroup::Ref table = to_disk.get_table<TestTableGroup>("test");
table->add("", 1, true, Wed);
table->add("", 15, true, Wed);
table->add("", 10, true, Wed);
table->add("", 20, true, Wed);
table->add("", 11, true, Wed);
table->add("", 45, true, Wed);
table->add("", 10, true, Wed);
table->add("", 0, true, Wed);
table->add("", 30, true, Wed);
table->add("", 9, true, Wed);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
#endif
// Delete old file if there
File::try_remove("table_test.tightdb");
// Serialize to disk
to_disk.write("table_test.tightdb");
// Load the table
Group from_disk("table_test.tightdb");
TestTableGroup::Ref t = from_disk.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(10, t->size());
// Verify that original values are there
CHECK(*table == *t);
// Modify both tables
table[0].first = "test";
t[0].first = "test";
table->insert(5, "hello", 100, false, Mon);
t->insert(5, "hello", 100, false, Mon);
table->remove(1);
t->remove(1);
// Verify that both changed correctly
CHECK(*table == *t);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
from_disk.Verify();
#endif
}
TEST(Group_Read1)
{
// Load the group and let it clean up without loading
// any tables
Group g("table_test.tightdb");
}
TEST(Group_Serialize2)
{
// Create group with two tables
Group to_disk;
TestTableGroup::Ref table1 = to_disk.get_table<TestTableGroup>("test1");
table1->add("", 1, true, Wed);
table1->add("", 15, true, Wed);
table1->add("", 10, true, Wed);
TestTableGroup::Ref table2 = to_disk.get_table<TestTableGroup>("test2");
table2->add("hey", 0, true, Tue);
table2->add("hello", 3232, false, Sun);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
#endif
// Delete old file if there
File::try_remove("table_test.tightdb");
// Serialize to disk
to_disk.write("table_test.tightdb");
// Load the tables
Group from_disk("table_test.tightdb");
TestTableGroup::Ref t1 = from_disk.get_table<TestTableGroup>("test1");
TestTableGroup::Ref t2 = from_disk.get_table<TestTableGroup>("test2");
static_cast<void>(t2);
static_cast<void>(t1);
// Verify that original values are there
CHECK(*table1 == *t1);
CHECK(*table2 == *t2);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
from_disk.Verify();
#endif
}
TEST(Group_Serialize3)
{
// Create group with one table (including long strings
Group to_disk;
TestTableGroup::Ref table = to_disk.get_table<TestTableGroup>("test");
table->add("1 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx 1", 1, true, Wed);
table->add("2 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx 2", 15, true, Wed);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
#endif
// Delete old file if there
File::try_remove("table_test.tightdb");
// Serialize to disk
to_disk.write("table_test.tightdb");
// Load the table
Group from_disk("table_test.tightdb");
TestTableGroup::Ref t = from_disk.get_table<TestTableGroup>("test");
static_cast<void>(t);
// Verify that original values are there
CHECK(*table == *t);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
from_disk.Verify();
#endif
}
TEST(Group_Serialize_Mem)
{
// Create group with one table
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
table->add("", 1, true, Wed);
table->add("", 15, true, Wed);
table->add("", 10, true, Wed);
table->add("", 20, true, Wed);
table->add("", 11, true, Wed);
table->add("", 45, true, Wed);
table->add("", 10, true, Wed);
table->add("", 0, true, Wed);
table->add("", 30, true, Wed);
table->add("", 9, true, Wed);
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
#endif
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TestTableGroup::Ref t = from_mem.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(10, t->size());
// Verify that original values are there
CHECK(*table == *t);
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
from_mem.Verify();
#endif
}
TEST(Group_Close)
{
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
table->add("", 1, true, Wed);
table->add("", 2, true, Wed);
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
Group from_mem(buffer);
}
TEST(Group_Serialize_Optimized)
{
// Create group with one table
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
for (size_t i = 0; i < 5; ++i) {
table->add("abd", 1, true, Mon);
table->add("eftg", 2, true, Tue);
table->add("hijkl", 5, true, Wed);
table->add("mnopqr", 8, true, Thu);
table->add("stuvxyz", 9, true, Fri);
}
table->optimize();
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
#endif
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TestTableGroup::Ref t = from_mem.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
// Verify that original values are there
CHECK(*table == *t);
// Add a row with a known (but unique) value
table->add("search_target", 9, true, Fri);
const size_t res = table->column().first.find_first("search_target");
CHECK_EQUAL(table->size()-1, res);
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
from_mem.Verify();
#endif
}
TEST(Group_Serialize_All)
{
// Create group with one table
Group to_mem;
TableRef table = to_mem.get_table("test");
table->add_column(type_Int, "int");
table->add_column(type_Bool, "bool");
table->add_column(type_DateTime, "date");
table->add_column(type_String, "string");
table->add_column(type_Binary, "binary");
table->add_column(type_Mixed, "mixed");
table->insert_int(0, 0, 12);
table->insert_bool(1, 0, true);
table->insert_datetime(2, 0, 12345);
table->insert_string(3, 0, "test");
table->insert_binary(4, 0, BinaryData("binary", 7));
table->insert_mixed(5, 0, false);
table->insert_done();
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TableRef t = from_mem.get_table("test");
CHECK_EQUAL(6, t->get_column_count());
CHECK_EQUAL(1, t->size());
CHECK_EQUAL(12, t->get_int(0, 0));
CHECK_EQUAL(true, t->get_bool(1, 0));
CHECK_EQUAL(time_t(12345), t->get_datetime(2, 0));
CHECK_EQUAL("test", t->get_string(3, 0));
CHECK_EQUAL(7, t->get_binary(4, 0).size());
CHECK_EQUAL("binary", t->get_binary(4, 0).data());
CHECK_EQUAL(type_Bool, t->get_mixed(5, 0).get_type());
CHECK_EQUAL(false, t->get_mixed(5, 0).get_bool());
}
TEST(Group_Persist)
{
// Delete old file if there
File::try_remove("testdb.tightdb");
// Create new database
Group db("testdb.tightdb", Group::mode_ReadWrite);
// Insert some data
TableRef table = db.get_table("test");
table->add_column(type_Int, "int");
table->add_column(type_Bool, "bool");
table->add_column(type_DateTime, "date");
table->add_column(type_String, "string");
table->add_column(type_Binary, "binary");
table->add_column(type_Mixed, "mixed");
table->insert_int(0, 0, 12);
table->insert_bool(1, 0, true);
table->insert_datetime(2, 0, 12345);
table->insert_string(3, 0, "test");
table->insert_binary(4, 0, BinaryData("binary", 7));
table->insert_mixed(5, 0, false);
table->insert_done();
// Write changes to file
db.commit();
#ifdef TIGHTDB_DEBUG
db.Verify();
#endif
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(1, table->size());
CHECK_EQUAL(12, table->get_int(0, 0));
CHECK_EQUAL(true, table->get_bool(1, 0));
CHECK_EQUAL(time_t(12345), table->get_datetime(2, 0));
CHECK_EQUAL("test", table->get_string(3, 0));
CHECK_EQUAL(7, table->get_binary(4, 0).size());
CHECK_EQUAL("binary", table->get_binary(4, 0).data());
CHECK_EQUAL(type_Bool, table->get_mixed(5, 0).get_type());
CHECK_EQUAL(false, table->get_mixed(5, 0).get_bool());
// Change a bit
table->set_string(3, 0, "Changed!");
// Write changes to file
db.commit();
#ifdef TIGHTDB_DEBUG
db.Verify();
#endif
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(1, table->size());
CHECK_EQUAL(12, table->get_int(0, 0));
CHECK_EQUAL(true, table->get_bool(1, 0));
CHECK_EQUAL(time_t(12345), table->get_datetime(2, 0));
CHECK_EQUAL("Changed!", table->get_string(3, 0));
CHECK_EQUAL(7, table->get_binary(4, 0).size());
CHECK_EQUAL("binary", table->get_binary(4, 0).data());
CHECK_EQUAL(type_Bool, table->get_mixed(5, 0).get_type());
CHECK_EQUAL(false, table->get_mixed(5, 0).get_bool());
}
TEST(Group_Subtable)
{
int n = 1;
Group g;
TableRef table = g.get_table("test");
DescriptorRef sub;
table->add_column(type_Int, "foo");
table->add_column(type_Table, "sub", &sub);
table->add_column(type_Mixed, "baz");
sub->add_column(type_Int, "bar");
sub.reset();
for (int i=0; i<n; ++i) {
table->add_empty_row();
table->set_int(0, i, 100+i);
if (i%2 == 0) {
TableRef st = table->get_subtable(1,i);
st->add_empty_row();
st->set_int(0, 0, 200+i);
}
if (i%3 == 1) {
table->set_mixed(2, i, Mixed::subtable_tag());
TableRef st = table->get_subtable(2,i);
st->add_column(type_Int, "banach");
st->add_empty_row();
st->set_int(0, 0, 700+i);
}
}
CHECK_EQUAL(n, table->size());
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table->get_int(0,i));
{
TableRef st = table->get_subtable(1,i);
CHECK_EQUAL(i%2 == 0 ? 1 : 0, st->size());
if (i%2 == 0)
CHECK_EQUAL(200+i, st->get_int(0,0));
if (i%3 == 0) {
st->add_empty_row();
st->set_int(0, st->size()-1, 300+i);
}
}
CHECK_EQUAL(i%3 == 1 ? type_Table : type_Int, table->get_mixed_type(2,i));
if (i%3 == 1) {
TableRef st = table->get_subtable(2,i);
CHECK_EQUAL(1, st->size());
CHECK_EQUAL(700+i, st->get_int(0,0));
}
if (i%8 == 3) {
if (i%3 != 1)
table->set_mixed(2, i, Mixed::subtable_tag());
TableRef st = table->get_subtable(2,i);
if (i%3 != 1)
st->add_column(type_Int, "banach");
st->add_empty_row();
st->set_int(0, st->size()-1, 800+i);
}
}
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table->get_int(0,i));
{
TableRef st = table->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 ? type_Table : type_Int, table->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3) {
TableRef st = table->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
}
}
File::try_remove("subtables.tightdb");
g.write("subtables.tightdb");
// Read back tables
Group g2("subtables.tightdb");
TableRef table2 = g2.get_table("test");
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table2->get_int(0,i));
{
TableRef st = table2->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
if (i%5 == 0) {
st->add_empty_row();
st->set_int(0, st->size()-1, 400+i);
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 ? type_Table : type_Int, table2->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3) {
TableRef st = table2->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
}
if (i%7 == 4) {
if (i%3 != 1 && i%8 != 3)
table2->set_mixed(2, i, Mixed::subtable_tag());
TableRef st = table2->get_subtable(2,i);
if (i%3 != 1 && i%8 != 3)
st->add_column(type_Int, "banach");
st->add_empty_row();
st->set_int(0, st->size()-1, 900+i);
}
}
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table2->get_int(0,i));
{
TableRef st = table2->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0) + (i%5 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
if (i%5 == 0) {
CHECK_EQUAL(400+i, st->get_int(0, ndx));
++ndx;
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 || i%7 == 4 ? type_Table : type_Int, table2->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3 || i%7 == 4) {
TableRef st = table2->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0) + (i%7 == 4 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
if (i%7 == 4) {
CHECK_EQUAL(900+i, st->get_int(0, ndx));
++ndx;
}
}
}
File::try_remove("subtables2.tightdb");
g2.write("subtables2.tightdb");
// Read back tables
Group g3("subtables2.tightdb");
TableRef table3 = g2.get_table("test");
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table3->get_int(0,i));
{
TableRef st = table3->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0) + (i%5 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
if (i%5 == 0) {
CHECK_EQUAL(400+i, st->get_int(0, ndx));
++ndx;
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 || i%7 == 4 ? type_Table : type_Int, table3->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3 || i%7 == 4) {
TableRef st = table3->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0) + (i%7 == 4 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
if (i%7 == 4) {
CHECK_EQUAL(900+i, st->get_int(0, ndx));
++ndx;
}
}
}
}
TEST(Group_MultiLevelSubtables)
{
{
Group g;
TableRef table = g.get_table("test");
{
DescriptorRef sub_1, sub_2;
table->add_column(type_Int, "int");
table->add_column(type_Table, "tab", &sub_1);
table->add_column(type_Mixed, "mix");
sub_1->add_column(type_Int, "int");
sub_1->add_column(type_Table, "tab", &sub_2);
sub_2->add_column(type_Int, "int");
}
table->add_empty_row();
{
TableRef a = table->get_subtable(1, 0);
a->add_empty_row();
TableRef b = a->get_subtable(1, 0);
b->add_empty_row();
}
{
table->set_mixed(2, 0, Mixed::subtable_tag());
TableRef a = table->get_subtable(2, 0);
a->add_column(type_Int, "int");
a->add_column(type_Mixed, "mix");
a->add_empty_row();
a->set_mixed(1, 0, Mixed::subtable_tag());
TableRef b = a->get_subtable(1, 0);
b->add_column(type_Int, "int");
b->add_empty_row();
}
File::try_remove("subtables.tightdb");
g.write("subtables.tightdb");
}
// Non-mixed
{
Group g("subtables.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(1, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Modify B
b->set_int(0, 0, 6661012);
// Modify A
a->set_int(0, 0, 6661011);
// Modify top
table->set_int(0, 0, 6661010);
// Get a second ref to A (compare)
CHECK_EQUAL(table->get_subtable(1, 0), a);
CHECK_EQUAL(table->get_subtable(1, 0)->get_int(0,0), 6661011);
// get a second ref to B (compare)
CHECK_EQUAL(a->get_subtable(1, 0), b);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661012);
File::try_remove("subtables2.tightdb");
g.write("subtables2.tightdb");
}
{
Group g("subtables2.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(1, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Drop reference to A
a = TableRef();
// Modify B
b->set_int(0, 0, 6661013);
// Get a third ref to A (compare)
a = table->get_subtable(1, 0);
CHECK_EQUAL(table->get_subtable(1, 0)->get_int(0,0), 6661011);
// Get third ref to B and verify last mod
b = a->get_subtable(1, 0);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661013);
File::try_remove("subtables3.tightdb");
g.write("subtables3.tightdb");
}
// Mixed
{
Group g("subtables3.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(2, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Modify B
b->set_int(0, 0, 6661012);
// Modify A
a->set_int(0, 0, 6661011);
// Modify top
table->set_int(0, 0, 6661010);
// Get a second ref to A (compare)
CHECK_EQUAL(table->get_subtable(2, 0), a);
CHECK_EQUAL(table->get_subtable(2, 0)->get_int(0,0), 6661011);
// get a second ref to B (compare)
CHECK_EQUAL(a->get_subtable(1, 0), b);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661012);
File::try_remove("subtables4.tightdb");
g.write("subtables4.tightdb");
}
{
Group g("subtables4.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(2, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Drop reference to A
a = TableRef();
// Modify B
b->set_int(0, 0, 6661013);
// Get a third ref to A (compare)
a = table->get_subtable(2, 0);
CHECK_EQUAL(table->get_subtable(2, 0)->get_int(0,0), 6661011);
// Get third ref to B and verify last mod
b = a->get_subtable(1, 0);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661013);
File::try_remove("subtables5.tightdb");
g.write("subtables5.tightdb");
}
}
TEST(Group_CommitSubtable)
{
File::try_remove("test.tightdb");
Group group("test.tightdb", Group::mode_ReadWrite);
TableRef table = group.get_table("test");
DescriptorRef sub_1;
table->add_column(type_Table, "subtable", &sub_1);
sub_1->add_column(type_Int, "int");
sub_1.reset();
table->add_empty_row();
TableRef subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
table->add_empty_row();
group.commit();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
table->add_empty_row();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
}
TEST(Group_CommitSubtableMixed)
{
File::try_remove("test.tightdb");
Group group("test.tightdb", Group::mode_ReadWrite);
TableRef table = group.get_table("test");
table->add_column(type_Mixed, "mixed");
table->add_empty_row();
table->clear_subtable(0,0);
TableRef subtable = table->get_subtable(0,0);
subtable->add_column(type_Int, "int");
subtable->add_empty_row();
group.commit();
table->add_empty_row();
group.commit();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
table->add_empty_row();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
}
namespace {
TIGHTDB_TABLE_3(TestTableGroup2,
first, Mixed,
second, Subtable<TestTableGroup>,
third, Subtable<TestTableGroup>)
} // anonymous namespace
TEST(Group_InvalidateTables)
{
TestTableGroup2::Ref table;
TableRef subtable1;
TestTableGroup::Ref subtable2;
TestTableGroup::Ref subtable3;
{
Group group;
table = group.get_table<TestTableGroup2>("foo");
CHECK(table->is_attached());
table->add(Mixed::subtable_tag(), 0, 0);
CHECK(table->is_attached());
subtable1 = table[0].first.get_subtable();
CHECK(table->is_attached());
CHECK(subtable1);
CHECK(subtable1->is_attached());
subtable2 = table[0].second;
CHECK(table->is_attached());
CHECK(subtable1->is_attached());
CHECK(subtable2);
CHECK(subtable2->is_attached());
subtable3 = table[0].third;
CHECK(table->is_attached());
CHECK(subtable1->is_attached());
CHECK(subtable2->is_attached());
CHECK(subtable3);
CHECK(subtable3->is_attached());
subtable3->add("alpha", 79542, true, Wed);
subtable3->add("beta", 97, false, Mon);
CHECK(table->is_attached());
CHECK(subtable1->is_attached());
CHECK(subtable2->is_attached());
CHECK(subtable3->is_attached());
}
CHECK(!table->is_attached());
CHECK(!subtable1->is_attached());
CHECK(!subtable2->is_attached());
CHECK(!subtable3->is_attached());
}
TEST(Group_toJSON)
{
Group g;
TestTableGroup::Ref table = g.get_table<TestTableGroup>("test");
table->add("jeff", 1, true, Wed);
table->add("jim", 1, true, Wed);
ostringstream out;
g.to_json(out);
string str = out.str();
CHECK(str.length() > 0);
CHECK_EQUAL("{\"test\":[{\"first\":\"jeff\",\"second\":1,\"third\":true,\"fourth\":2},{\"first\":\"jim\",\"second\":1,\"third\":true,\"fourth\":2}]}", str);
}
TEST(Group_toString)
{
Group g;
TestTableGroup::Ref table = g.get_table<TestTableGroup>("test");
table->add("jeff", 1, true, Wed);
table->add("jim", 1, true, Wed);
ostringstream out;
g.to_string(out);
string str = out.str();
CHECK(str.length() > 0);
CHECK_EQUAL(" tables rows \n 0 test 2 \n", str.c_str());
}
TEST(Group_Index_String)
{
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
table->add("jeff", 1, true, Wed);
table->add("jim", 1, true, Wed);
table->add("jennifer", 1, true, Wed);
table->add("john", 1, true, Wed);
table->add("jimmy", 1, true, Wed);
table->add("jimbo", 1, true, Wed);
table->add("johnny", 1, true, Wed);
table->add("jennifer", 1, true, Wed); //duplicate
table->column().first.set_index();
CHECK(table->column().first.has_index());
size_t r1 = table->column().first.find_first("jimmi");
CHECK_EQUAL(not_found, r1);
size_t r2 = table->column().first.find_first("jeff");
size_t r3 = table->column().first.find_first("jim");
size_t r4 = table->column().first.find_first("jimbo");
size_t r5 = table->column().first.find_first("johnny");
CHECK_EQUAL(0, r2);
CHECK_EQUAL(1, r3);
CHECK_EQUAL(5, r4);
CHECK_EQUAL(6, r5);
size_t c1 = table->column().first.count("jennifer");
CHECK_EQUAL(2, c1);
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TestTableGroup::Ref t = from_mem.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(8, t->size());
CHECK(t->column().first.has_index());
size_t m1 = table->column().first.find_first("jimmi");
CHECK_EQUAL(not_found, m1);
size_t m2 = t->column().first.find_first("jeff");
size_t m3 = t->column().first.find_first("jim");
size_t m4 = t->column().first.find_first("jimbo");
size_t m5 = t->column().first.find_first("johnny");
CHECK_EQUAL(0, m2);
CHECK_EQUAL(1, m3);
CHECK_EQUAL(5, m4);
CHECK_EQUAL(6, m5);
size_t m6 = t->column().first.count("jennifer");
CHECK_EQUAL(2, m6);
}
#ifdef TIGHTDB_DEBUG
#ifdef TIGHTDB_TO_DOT
TEST(Group_ToDot)
{
// Create group with one table
Group mygroup;
// Create table with all column types
TableRef table = mygroup.get_table("test");
DescriptorRef subdesc;
s.add_column(type_Int, "int");
s.add_column(type_Bool, "bool");
s.add_column(type_DateTime, "date");
s.add_column(type_String, "string");
s.add_column(type_String, "string_long");
s.add_column(type_String, "string_enum"); // becomes ColumnStringEnum
s.add_column(type_Binary, "binary");
s.add_column(type_Mixed, "mixed");
s.add_column(type_Table, "tables", &subdesc);
subdesc->add_column(type_Int, "sub_first");
subdesc->add_column(type_String, "sub_second");
// Add some rows
for (size_t i = 0; i < 15; ++i) {
table->insert_int(0, i, i);
table->insert_bool(1, i, (i % 2 ? true : false));
table->insert_datetime(2, i, 12345);
stringstream ss;
ss << "string" << i;
table->insert_string(3, i, ss.str().c_str());
ss << " very long string.........";
table->insert_string(4, i, ss.str().c_str());
switch (i % 3) {
case 0:
table->insert_string(5, i, "test1");
break;
case 1:
table->insert_string(5, i, "test2");
break;
case 2:
table->insert_string(5, i, "test3");
break;
}
table->insert_binary(6, i, "binary", 7);
switch (i % 3) {
case 0:
table->insert_mixed(7, i, false);
break;
case 1:
table->insert_mixed(7, i, (int64_t)i);
break;
case 2:
table->insert_mixed(7, i, "string");
break;
}
table->insert_subtable(8, i);
table->insert_done();
// Add sub-tables
if (i == 2) {
// To mixed column
table->set_mixed(7, i, Mixed(type_Table));
Table subtable = table->GetMixedTable(7, i);
Spec s = subtable->get_spec();
s.add_column(type_Int, "first");
s.add_column(type_String, "second");
subtable->UpdateFromSpec(s.get_ref());
subtable->insert_int(0, 0, 42);
subtable->insert_string(1, 0, "meaning");
subtable->insert_done();
// To table column
Table subtable2 = table->get_subtable(8, i);
subtable2->insert_int(0, 0, 42);
subtable2->insert_string(1, 0, "meaning");
subtable2->insert_done();
}
}
// We also want ColumnStringEnum's
table->optimize();
#if 1
// Write array graph to cout
stringstream ss;
mygroup.ToDot(ss);
cout << ss.str() << endl;
#endif
// Write array graph to file in dot format
ofstream fs("tightdb_graph.dot", ios::out | ios::binary);
if (!fs.is_open())
cout << "file open error " << strerror << endl;
mygroup.to_dot(fs);
fs.close();
}
#endif // TIGHTDB_TO_DOT
#endif // TIGHTDB_DEBUG
#endif // TEST_GROUP
added testcase
#include "testsettings.hpp"
#ifdef TEST_GROUP
#include <algorithm>
#include <fstream>
#include <sys/stat.h>
// File permissions for Windows
// http://stackoverflow.com/questions/592448/c-how-to-set-file-permissions-cross-platform
#ifdef _WIN32
#include <io.h>
typedef int mode_t;
static const mode_t S_IWUSR = mode_t(_S_IWRITE);
static const mode_t MS_MODE_MASK = 0x0000ffff;
#endif
#include <UnitTest++.h>
#include <tightdb.hpp>
#include <tightdb/util/file.hpp>
using namespace std;
using namespace tightdb;
using namespace tightdb::util;
// Note: You can now temporarely declare unit tests with the ONLY(TestName) macro instead of TEST(TestName). This
// will disable all unit tests except these. Remember to undo your temporary changes before committing.
namespace {
enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
TIGHTDB_TABLE_4(TestTableGroup,
first, String,
second, Int,
third, Bool,
fourth, Enum<Days>)
} // Anonymous namespace
TEST(Group_Unattached)
{
Group group((Group::unattached_tag()));
CHECK(!group.is_attached());
}
TEST(Group_OpenFile)
{
File::try_remove("test.tightdb");
{
Group group((Group::unattached_tag()));
group.open("test.tightdb", Group::mode_ReadWrite);
CHECK(group.is_attached());
}
{
Group group((Group::unattached_tag()));
group.open("test.tightdb", Group::mode_ReadWriteNoCreate);
CHECK(group.is_attached());
}
{
Group group((Group::unattached_tag()));
group.open("test.tightdb", Group::mode_ReadOnly);
CHECK(group.is_attached());
}
File::remove("test.tightdb");
}
TEST(Group_Permissions)
{
util::File::try_remove("test.tightdb");
{
Group group1;
TableRef t1 = group1.get_table("table1");
t1->add_column(type_String, "s");
t1->add_column(type_Int, "i");
for(size_t i=0; i<4; ++i) {
t1->insert_string(0, i, "a");
t1->insert_int(1, i, 3);
t1->insert_done();
}
group1.write("test.tightdb");
}
#ifdef _WIN32
_chmod("test.tightdb", S_IWUSR & MS_MODE_MASK);
#else
chmod("test.tightdb", S_IWUSR);
#endif
{
Group group2((Group::unattached_tag()));
CHECK_THROW(group2.open("test.tightdb", Group::mode_ReadOnly), util::File::PermissionDenied);
CHECK(!group2.has_table("table1")); // is not attached
}
util::File::try_remove("test.tightdb");
}
TEST(Group_BadFile)
{
File::try_remove("test.tightdb");
File::try_remove("test2.tightdb");
{
File file("test.tightdb", File::mode_Append);
file.write("foo");
}
{
Group group((Group::unattached_tag()));
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadOnly), InvalidDatabase);
CHECK(!group.is_attached());
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadOnly), InvalidDatabase); // Again
CHECK(!group.is_attached());
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadWrite), InvalidDatabase);
CHECK(!group.is_attached());
CHECK_THROW(group.open("test.tightdb", Group::mode_ReadWriteNoCreate), InvalidDatabase);
CHECK(!group.is_attached());
group.open("test2.tightdb", Group::mode_ReadWrite); // This one must work
CHECK(group.is_attached());
}
File::remove("test.tightdb");
File::remove("test2.tightdb");
}
TEST(Group_OpenBuffer)
{
// Produce a valid buffer
UniquePtr<char[]> buffer;
size_t buffer_size;
{
File::try_remove("test.tightdb");
{
Group group;
group.write("test.tightdb");
}
{
File file("test.tightdb");
buffer_size = size_t(file.get_size());
buffer.reset(static_cast<char*>(malloc(buffer_size)));
CHECK(bool(buffer));
file.read(buffer.get(), buffer_size);
}
File::remove("test.tightdb");
}
// Keep ownership of buffer
{
Group group((Group::unattached_tag()));
bool take_ownership = false;
group.open(BinaryData(buffer.get(), buffer_size), take_ownership);
CHECK(group.is_attached());
}
// Pass ownership of buffer
{
Group group((Group::unattached_tag()));
bool take_ownership = true;
group.open(BinaryData(buffer.get(), buffer_size), take_ownership);
CHECK(group.is_attached());
buffer.release();
}
}
TEST(Group_BadBuffer)
{
File::try_remove("test.tightdb");
// Produce an invalid buffer
char buffer[32];
for (size_t i=0; i<sizeof buffer; ++i)
buffer[i] = char((i+192)%128);
{
Group group((Group::unattached_tag()));
bool take_ownership = false;
CHECK_THROW(group.open(BinaryData(buffer), take_ownership), InvalidDatabase);
CHECK(!group.is_attached());
// Check that ownership is not passed on failure during
// open. If it was, we would get a bad delete on stack
// allocated memory wich would at least be caught by Valgrind.
take_ownership = true;
CHECK_THROW(group.open(BinaryData(buffer), take_ownership), InvalidDatabase);
CHECK(!group.is_attached());
// Check that the group is still able to attach to a file,
// even after failures.
group.open("test.tightdb", Group::mode_ReadWrite);
CHECK(group.is_attached());
}
File::remove("test.tightdb");
}
TEST(Group_Size)
{
Group g;
CHECK(g.is_attached());
CHECK(g.is_empty());
TableRef t = g.get_table("a");
CHECK(!g.is_empty());
CHECK_EQUAL(1, g.size());
TableRef t1 = g.get_table("b");
CHECK(!g.is_empty());
CHECK_EQUAL(2, g.size());
}
TEST(Group_GetTable)
{
Group g;
const Group& cg = g;
TableRef t1 = g.get_table("alpha");
ConstTableRef t2 = cg.get_table("alpha");
CHECK_EQUAL(t1, t2);
TestTableGroup::Ref t3 = g.get_table<TestTableGroup>("beta");
TestTableGroup::ConstRef t4 = cg.get_table<TestTableGroup>("beta");
CHECK_EQUAL(t3, t4);
}
TEST(Group_GetTableWasCreated)
{
Group group;
bool was_created = false;
group.get_table("foo", was_created);
CHECK(was_created);
group.get_table("foo", was_created);
CHECK(!was_created);
group.get_table("bar", was_created);
CHECK(was_created);
group.get_table("baz", was_created);
CHECK(was_created);
group.get_table("bar", was_created);
CHECK(!was_created);
group.get_table("baz", was_created);
CHECK(!was_created);
}
namespace {
void setup_table(TestTableGroup::Ref t)
{
t->add("a", 1, true, Wed);
t->add("b", 15, true, Wed);
t->add("ccc", 10, true, Wed);
t->add("dddd", 20, true, Wed);
}
}
TEST(Group_Equal)
{
Group g1, g2;
TestTableGroup::Ref t1 = g1.get_table<TestTableGroup>("TABLE1");
setup_table(t1);
TestTableGroup::Ref t2 = g2.get_table<TestTableGroup>("TABLE1");
setup_table(t2);
CHECK_EQUAL(true, g1 == g2);
t2->add("hey", 2, false, Thu);
CHECK_EQUAL(true, g1 != g2);
}
TEST(Group_TableAccessorLeftBehind)
{
TableRef table;
TableRef subtable;
{
Group group;
table = group.get_table("test");
CHECK(table->is_attached());
table->add_column(type_Table, "sub");
table->add_empty_row();
subtable = table->get_subtable(0,0);
CHECK(subtable->is_attached());
}
CHECK(!table->is_attached());
CHECK(!subtable->is_attached());
}
TEST(Group_Invalid1)
{
File::try_remove("table_test.tightdb");
// Try to open non-existing file
// (read-only files have to exists to before opening)
CHECK_THROW(Group("table_test.tightdb"), File::NotFound);
}
TEST(Group_Invalid2)
{
// Try to open buffer with invalid data
const char* const str = "invalid data";
const size_t size = strlen(str);
char* const data = new char[strlen(str)];
copy(str, str+size, data);
CHECK_THROW(Group(BinaryData(data, size)), InvalidDatabase);
delete[] data;
}
TEST(Group_Overwrite)
{
File::try_remove("test_overwrite.tightdb");
{
Group g;
g.write("test_overwrite.tightdb");
CHECK_THROW(g.write("test_overwrite.tightdb"), File::Exists);
}
{
Group g("test_overwrite.tightdb");
CHECK_THROW(g.write("test_overwrite.tightdb"), File::Exists);
}
{
Group g;
File::try_remove("test_overwrite.tightdb");
g.write("test_overwrite.tightdb");
}
}
TEST(Group_Serialize0)
{
File::try_remove("table_test.tightdb");
// Create empty group and serialize to disk
Group to_disk;
to_disk.write("table_test.tightdb");
// Load the group
Group from_disk("table_test.tightdb");
// Create new table in group
TestTableGroup::Ref t = from_disk.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(0, t->size());
// Modify table
t->add("Test", 1, true, Wed);
CHECK_EQUAL("Test", t[0].first);
CHECK_EQUAL(1, t[0].second);
CHECK_EQUAL(true, t[0].third);
CHECK_EQUAL(Wed, t[0].fourth);
}
TEST(Group_Read0)
{
// Load the group and let it clean up without loading
// any tables
Group g("table_test.tightdb");
}
TEST(Group_Serialize1)
{
// Create group with one table
Group to_disk;
TestTableGroup::Ref table = to_disk.get_table<TestTableGroup>("test");
table->add("", 1, true, Wed);
table->add("", 15, true, Wed);
table->add("", 10, true, Wed);
table->add("", 20, true, Wed);
table->add("", 11, true, Wed);
table->add("", 45, true, Wed);
table->add("", 10, true, Wed);
table->add("", 0, true, Wed);
table->add("", 30, true, Wed);
table->add("", 9, true, Wed);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
#endif
// Delete old file if there
File::try_remove("table_test.tightdb");
// Serialize to disk
to_disk.write("table_test.tightdb");
// Load the table
Group from_disk("table_test.tightdb");
TestTableGroup::Ref t = from_disk.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(10, t->size());
// Verify that original values are there
CHECK(*table == *t);
// Modify both tables
table[0].first = "test";
t[0].first = "test";
table->insert(5, "hello", 100, false, Mon);
t->insert(5, "hello", 100, false, Mon);
table->remove(1);
t->remove(1);
// Verify that both changed correctly
CHECK(*table == *t);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
from_disk.Verify();
#endif
}
TEST(Group_Read1)
{
// Load the group and let it clean up without loading
// any tables
Group g("table_test.tightdb");
}
TEST(Group_Serialize2)
{
// Create group with two tables
Group to_disk;
TestTableGroup::Ref table1 = to_disk.get_table<TestTableGroup>("test1");
table1->add("", 1, true, Wed);
table1->add("", 15, true, Wed);
table1->add("", 10, true, Wed);
TestTableGroup::Ref table2 = to_disk.get_table<TestTableGroup>("test2");
table2->add("hey", 0, true, Tue);
table2->add("hello", 3232, false, Sun);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
#endif
// Delete old file if there
File::try_remove("table_test.tightdb");
// Serialize to disk
to_disk.write("table_test.tightdb");
// Load the tables
Group from_disk("table_test.tightdb");
TestTableGroup::Ref t1 = from_disk.get_table<TestTableGroup>("test1");
TestTableGroup::Ref t2 = from_disk.get_table<TestTableGroup>("test2");
static_cast<void>(t2);
static_cast<void>(t1);
// Verify that original values are there
CHECK(*table1 == *t1);
CHECK(*table2 == *t2);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
from_disk.Verify();
#endif
}
TEST(Group_Serialize3)
{
// Create group with one table (including long strings
Group to_disk;
TestTableGroup::Ref table = to_disk.get_table<TestTableGroup>("test");
table->add("1 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx 1", 1, true, Wed);
table->add("2 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx 2", 15, true, Wed);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
#endif
// Delete old file if there
File::try_remove("table_test.tightdb");
// Serialize to disk
to_disk.write("table_test.tightdb");
// Load the table
Group from_disk("table_test.tightdb");
TestTableGroup::Ref t = from_disk.get_table<TestTableGroup>("test");
static_cast<void>(t);
// Verify that original values are there
CHECK(*table == *t);
#ifdef TIGHTDB_DEBUG
to_disk.Verify();
from_disk.Verify();
#endif
}
TEST(Group_Serialize_Mem)
{
// Create group with one table
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
table->add("", 1, true, Wed);
table->add("", 15, true, Wed);
table->add("", 10, true, Wed);
table->add("", 20, true, Wed);
table->add("", 11, true, Wed);
table->add("", 45, true, Wed);
table->add("", 10, true, Wed);
table->add("", 0, true, Wed);
table->add("", 30, true, Wed);
table->add("", 9, true, Wed);
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
#endif
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TestTableGroup::Ref t = from_mem.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(10, t->size());
// Verify that original values are there
CHECK(*table == *t);
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
from_mem.Verify();
#endif
}
TEST(Group_Close)
{
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
table->add("", 1, true, Wed);
table->add("", 2, true, Wed);
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
Group from_mem(buffer);
}
TEST(Group_Serialize_Optimized)
{
// Create group with one table
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
for (size_t i = 0; i < 5; ++i) {
table->add("abd", 1, true, Mon);
table->add("eftg", 2, true, Tue);
table->add("hijkl", 5, true, Wed);
table->add("mnopqr", 8, true, Thu);
table->add("stuvxyz", 9, true, Fri);
}
table->optimize();
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
#endif
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TestTableGroup::Ref t = from_mem.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
// Verify that original values are there
CHECK(*table == *t);
// Add a row with a known (but unique) value
table->add("search_target", 9, true, Fri);
const size_t res = table->column().first.find_first("search_target");
CHECK_EQUAL(table->size()-1, res);
#ifdef TIGHTDB_DEBUG
to_mem.Verify();
from_mem.Verify();
#endif
}
TEST(Group_Serialize_All)
{
// Create group with one table
Group to_mem;
TableRef table = to_mem.get_table("test");
table->add_column(type_Int, "int");
table->add_column(type_Bool, "bool");
table->add_column(type_DateTime, "date");
table->add_column(type_String, "string");
table->add_column(type_Binary, "binary");
table->add_column(type_Mixed, "mixed");
table->insert_int(0, 0, 12);
table->insert_bool(1, 0, true);
table->insert_datetime(2, 0, 12345);
table->insert_string(3, 0, "test");
table->insert_binary(4, 0, BinaryData("binary", 7));
table->insert_mixed(5, 0, false);
table->insert_done();
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TableRef t = from_mem.get_table("test");
CHECK_EQUAL(6, t->get_column_count());
CHECK_EQUAL(1, t->size());
CHECK_EQUAL(12, t->get_int(0, 0));
CHECK_EQUAL(true, t->get_bool(1, 0));
CHECK_EQUAL(time_t(12345), t->get_datetime(2, 0));
CHECK_EQUAL("test", t->get_string(3, 0));
CHECK_EQUAL(7, t->get_binary(4, 0).size());
CHECK_EQUAL("binary", t->get_binary(4, 0).data());
CHECK_EQUAL(type_Bool, t->get_mixed(5, 0).get_type());
CHECK_EQUAL(false, t->get_mixed(5, 0).get_bool());
}
TEST(Group_Persist)
{
// Delete old file if there
File::try_remove("testdb.tightdb");
// Create new database
Group db("testdb.tightdb", Group::mode_ReadWrite);
// Insert some data
TableRef table = db.get_table("test");
table->add_column(type_Int, "int");
table->add_column(type_Bool, "bool");
table->add_column(type_DateTime, "date");
table->add_column(type_String, "string");
table->add_column(type_Binary, "binary");
table->add_column(type_Mixed, "mixed");
table->insert_int(0, 0, 12);
table->insert_bool(1, 0, true);
table->insert_datetime(2, 0, 12345);
table->insert_string(3, 0, "test");
table->insert_binary(4, 0, BinaryData("binary", 7));
table->insert_mixed(5, 0, false);
table->insert_done();
// Write changes to file
db.commit();
#ifdef TIGHTDB_DEBUG
db.Verify();
#endif
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(1, table->size());
CHECK_EQUAL(12, table->get_int(0, 0));
CHECK_EQUAL(true, table->get_bool(1, 0));
CHECK_EQUAL(time_t(12345), table->get_datetime(2, 0));
CHECK_EQUAL("test", table->get_string(3, 0));
CHECK_EQUAL(7, table->get_binary(4, 0).size());
CHECK_EQUAL("binary", table->get_binary(4, 0).data());
CHECK_EQUAL(type_Bool, table->get_mixed(5, 0).get_type());
CHECK_EQUAL(false, table->get_mixed(5, 0).get_bool());
// Change a bit
table->set_string(3, 0, "Changed!");
// Write changes to file
db.commit();
#ifdef TIGHTDB_DEBUG
db.Verify();
#endif
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(1, table->size());
CHECK_EQUAL(12, table->get_int(0, 0));
CHECK_EQUAL(true, table->get_bool(1, 0));
CHECK_EQUAL(time_t(12345), table->get_datetime(2, 0));
CHECK_EQUAL("Changed!", table->get_string(3, 0));
CHECK_EQUAL(7, table->get_binary(4, 0).size());
CHECK_EQUAL("binary", table->get_binary(4, 0).data());
CHECK_EQUAL(type_Bool, table->get_mixed(5, 0).get_type());
CHECK_EQUAL(false, table->get_mixed(5, 0).get_bool());
}
TEST(Group_Subtable)
{
int n = 1;
Group g;
TableRef table = g.get_table("test");
DescriptorRef sub;
table->add_column(type_Int, "foo");
table->add_column(type_Table, "sub", &sub);
table->add_column(type_Mixed, "baz");
sub->add_column(type_Int, "bar");
sub.reset();
for (int i=0; i<n; ++i) {
table->add_empty_row();
table->set_int(0, i, 100+i);
if (i%2 == 0) {
TableRef st = table->get_subtable(1,i);
st->add_empty_row();
st->set_int(0, 0, 200+i);
}
if (i%3 == 1) {
table->set_mixed(2, i, Mixed::subtable_tag());
TableRef st = table->get_subtable(2,i);
st->add_column(type_Int, "banach");
st->add_empty_row();
st->set_int(0, 0, 700+i);
}
}
CHECK_EQUAL(n, table->size());
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table->get_int(0,i));
{
TableRef st = table->get_subtable(1,i);
CHECK_EQUAL(i%2 == 0 ? 1 : 0, st->size());
if (i%2 == 0)
CHECK_EQUAL(200+i, st->get_int(0,0));
if (i%3 == 0) {
st->add_empty_row();
st->set_int(0, st->size()-1, 300+i);
}
}
CHECK_EQUAL(i%3 == 1 ? type_Table : type_Int, table->get_mixed_type(2,i));
if (i%3 == 1) {
TableRef st = table->get_subtable(2,i);
CHECK_EQUAL(1, st->size());
CHECK_EQUAL(700+i, st->get_int(0,0));
}
if (i%8 == 3) {
if (i%3 != 1)
table->set_mixed(2, i, Mixed::subtable_tag());
TableRef st = table->get_subtable(2,i);
if (i%3 != 1)
st->add_column(type_Int, "banach");
st->add_empty_row();
st->set_int(0, st->size()-1, 800+i);
}
}
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table->get_int(0,i));
{
TableRef st = table->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 ? type_Table : type_Int, table->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3) {
TableRef st = table->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
}
}
File::try_remove("subtables.tightdb");
g.write("subtables.tightdb");
// Read back tables
Group g2("subtables.tightdb");
TableRef table2 = g2.get_table("test");
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table2->get_int(0,i));
{
TableRef st = table2->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
if (i%5 == 0) {
st->add_empty_row();
st->set_int(0, st->size()-1, 400+i);
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 ? type_Table : type_Int, table2->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3) {
TableRef st = table2->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
}
if (i%7 == 4) {
if (i%3 != 1 && i%8 != 3)
table2->set_mixed(2, i, Mixed::subtable_tag());
TableRef st = table2->get_subtable(2,i);
if (i%3 != 1 && i%8 != 3)
st->add_column(type_Int, "banach");
st->add_empty_row();
st->set_int(0, st->size()-1, 900+i);
}
}
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table2->get_int(0,i));
{
TableRef st = table2->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0) + (i%5 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
if (i%5 == 0) {
CHECK_EQUAL(400+i, st->get_int(0, ndx));
++ndx;
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 || i%7 == 4 ? type_Table : type_Int, table2->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3 || i%7 == 4) {
TableRef st = table2->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0) + (i%7 == 4 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
if (i%7 == 4) {
CHECK_EQUAL(900+i, st->get_int(0, ndx));
++ndx;
}
}
}
File::try_remove("subtables2.tightdb");
g2.write("subtables2.tightdb");
// Read back tables
Group g3("subtables2.tightdb");
TableRef table3 = g2.get_table("test");
for (int i=0; i<n; ++i) {
CHECK_EQUAL(100+i, table3->get_int(0,i));
{
TableRef st = table3->get_subtable(1,i);
size_t expected_size = (i%2 == 0 ? 1 : 0) + (i%3 == 0 ? 1 : 0) + (i%5 == 0 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%2 == 0) {
CHECK_EQUAL(200+i, st->get_int(0, ndx));
++ndx;
}
if (i%3 == 0) {
CHECK_EQUAL(300+i, st->get_int(0, ndx));
++ndx;
}
if (i%5 == 0) {
CHECK_EQUAL(400+i, st->get_int(0, ndx));
++ndx;
}
}
CHECK_EQUAL(i%3 == 1 || i%8 == 3 || i%7 == 4 ? type_Table : type_Int, table3->get_mixed_type(2,i));
if (i%3 == 1 || i%8 == 3 || i%7 == 4) {
TableRef st = table3->get_subtable(2,i);
size_t expected_size = (i%3 == 1 ? 1 : 0) + (i%8 == 3 ? 1 : 0) + (i%7 == 4 ? 1 : 0);
CHECK_EQUAL(expected_size, st->size());
size_t ndx = 0;
if (i%3 == 1) {
CHECK_EQUAL(700+i, st->get_int(0, ndx));
++ndx;
}
if (i%8 == 3) {
CHECK_EQUAL(800+i, st->get_int(0, ndx));
++ndx;
}
if (i%7 == 4) {
CHECK_EQUAL(900+i, st->get_int(0, ndx));
++ndx;
}
}
}
}
TEST(Group_MultiLevelSubtables)
{
{
Group g;
TableRef table = g.get_table("test");
{
DescriptorRef sub_1, sub_2;
table->add_column(type_Int, "int");
table->add_column(type_Table, "tab", &sub_1);
table->add_column(type_Mixed, "mix");
sub_1->add_column(type_Int, "int");
sub_1->add_column(type_Table, "tab", &sub_2);
sub_2->add_column(type_Int, "int");
}
table->add_empty_row();
{
TableRef a = table->get_subtable(1, 0);
a->add_empty_row();
TableRef b = a->get_subtable(1, 0);
b->add_empty_row();
}
{
table->set_mixed(2, 0, Mixed::subtable_tag());
TableRef a = table->get_subtable(2, 0);
a->add_column(type_Int, "int");
a->add_column(type_Mixed, "mix");
a->add_empty_row();
a->set_mixed(1, 0, Mixed::subtable_tag());
TableRef b = a->get_subtable(1, 0);
b->add_column(type_Int, "int");
b->add_empty_row();
}
File::try_remove("subtables.tightdb");
g.write("subtables.tightdb");
}
// Non-mixed
{
Group g("subtables.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(1, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Modify B
b->set_int(0, 0, 6661012);
// Modify A
a->set_int(0, 0, 6661011);
// Modify top
table->set_int(0, 0, 6661010);
// Get a second ref to A (compare)
CHECK_EQUAL(table->get_subtable(1, 0), a);
CHECK_EQUAL(table->get_subtable(1, 0)->get_int(0,0), 6661011);
// get a second ref to B (compare)
CHECK_EQUAL(a->get_subtable(1, 0), b);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661012);
File::try_remove("subtables2.tightdb");
g.write("subtables2.tightdb");
}
{
Group g("subtables2.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(1, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Drop reference to A
a = TableRef();
// Modify B
b->set_int(0, 0, 6661013);
// Get a third ref to A (compare)
a = table->get_subtable(1, 0);
CHECK_EQUAL(table->get_subtable(1, 0)->get_int(0,0), 6661011);
// Get third ref to B and verify last mod
b = a->get_subtable(1, 0);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661013);
File::try_remove("subtables3.tightdb");
g.write("subtables3.tightdb");
}
// Mixed
{
Group g("subtables3.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(2, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Modify B
b->set_int(0, 0, 6661012);
// Modify A
a->set_int(0, 0, 6661011);
// Modify top
table->set_int(0, 0, 6661010);
// Get a second ref to A (compare)
CHECK_EQUAL(table->get_subtable(2, 0), a);
CHECK_EQUAL(table->get_subtable(2, 0)->get_int(0,0), 6661011);
// get a second ref to B (compare)
CHECK_EQUAL(a->get_subtable(1, 0), b);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661012);
File::try_remove("subtables4.tightdb");
g.write("subtables4.tightdb");
}
{
Group g("subtables4.tightdb");
TableRef table = g.get_table("test");
// Get A as subtable
TableRef a = table->get_subtable(2, 0);
// Get B as subtable from A
TableRef b = a->get_subtable(1, 0);
// Drop reference to A
a = TableRef();
// Modify B
b->set_int(0, 0, 6661013);
// Get a third ref to A (compare)
a = table->get_subtable(2, 0);
CHECK_EQUAL(table->get_subtable(2, 0)->get_int(0,0), 6661011);
// Get third ref to B and verify last mod
b = a->get_subtable(1, 0);
CHECK_EQUAL(a->get_subtable(1, 0)->get_int(0,0), 6661013);
File::try_remove("subtables5.tightdb");
g.write("subtables5.tightdb");
}
}
TEST(Group_CommitSubtable)
{
File::try_remove("test.tightdb");
Group group("test.tightdb", Group::mode_ReadWrite);
TableRef table = group.get_table("test");
DescriptorRef sub_1;
table->add_column(type_Table, "subtable", &sub_1);
sub_1->add_column(type_Int, "int");
sub_1.reset();
table->add_empty_row();
TableRef subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
table->add_empty_row();
group.commit();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
table->add_empty_row();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
}
TEST(Group_CommitSubtableMixed)
{
File::try_remove("test.tightdb");
Group group("test.tightdb", Group::mode_ReadWrite);
TableRef table = group.get_table("test");
table->add_column(type_Mixed, "mixed");
table->add_empty_row();
table->clear_subtable(0,0);
TableRef subtable = table->get_subtable(0,0);
subtable->add_column(type_Int, "int");
subtable->add_empty_row();
group.commit();
table->add_empty_row();
group.commit();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
table->add_empty_row();
subtable = table->get_subtable(0,0);
subtable->add_empty_row();
group.commit();
}
namespace {
TIGHTDB_TABLE_3(TestTableGroup2,
first, Mixed,
second, Subtable<TestTableGroup>,
third, Subtable<TestTableGroup>)
} // anonymous namespace
TEST(Group_InvalidateTables)
{
TestTableGroup2::Ref table;
TableRef subtable1;
TestTableGroup::Ref subtable2;
TestTableGroup::Ref subtable3;
{
Group group;
table = group.get_table<TestTableGroup2>("foo");
CHECK(table->is_attached());
table->add(Mixed::subtable_tag(), 0, 0);
CHECK(table->is_attached());
subtable1 = table[0].first.get_subtable();
CHECK(table->is_attached());
CHECK(subtable1);
CHECK(subtable1->is_attached());
subtable2 = table[0].second;
CHECK(table->is_attached());
CHECK(subtable1->is_attached());
CHECK(subtable2);
CHECK(subtable2->is_attached());
subtable3 = table[0].third;
CHECK(table->is_attached());
CHECK(subtable1->is_attached());
CHECK(subtable2->is_attached());
CHECK(subtable3);
CHECK(subtable3->is_attached());
subtable3->add("alpha", 79542, true, Wed);
subtable3->add("beta", 97, false, Mon);
CHECK(table->is_attached());
CHECK(subtable1->is_attached());
CHECK(subtable2->is_attached());
CHECK(subtable3->is_attached());
}
CHECK(!table->is_attached());
CHECK(!subtable1->is_attached());
CHECK(!subtable2->is_attached());
CHECK(!subtable3->is_attached());
}
TEST(Group_toJSON)
{
Group g;
TestTableGroup::Ref table = g.get_table<TestTableGroup>("test");
table->add("jeff", 1, true, Wed);
table->add("jim", 1, true, Wed);
ostringstream out;
g.to_json(out);
string str = out.str();
CHECK(str.length() > 0);
CHECK_EQUAL("{\"test\":[{\"first\":\"jeff\",\"second\":1,\"third\":true,\"fourth\":2},{\"first\":\"jim\",\"second\":1,\"third\":true,\"fourth\":2}]}", str);
}
TEST(Group_toString)
{
Group g;
TestTableGroup::Ref table = g.get_table<TestTableGroup>("test");
table->add("jeff", 1, true, Wed);
table->add("jim", 1, true, Wed);
ostringstream out;
g.to_string(out);
string str = out.str();
CHECK(str.length() > 0);
CHECK_EQUAL(" tables rows \n 0 test 2 \n", str.c_str());
}
TEST(Group_Index_String)
{
Group to_mem;
TestTableGroup::Ref table = to_mem.get_table<TestTableGroup>("test");
table->add("jeff", 1, true, Wed);
table->add("jim", 1, true, Wed);
table->add("jennifer", 1, true, Wed);
table->add("john", 1, true, Wed);
table->add("jimmy", 1, true, Wed);
table->add("jimbo", 1, true, Wed);
table->add("johnny", 1, true, Wed);
table->add("jennifer", 1, true, Wed); //duplicate
table->column().first.set_index();
CHECK(table->column().first.has_index());
size_t r1 = table->column().first.find_first("jimmi");
CHECK_EQUAL(not_found, r1);
size_t r2 = table->column().first.find_first("jeff");
size_t r3 = table->column().first.find_first("jim");
size_t r4 = table->column().first.find_first("jimbo");
size_t r5 = table->column().first.find_first("johnny");
CHECK_EQUAL(0, r2);
CHECK_EQUAL(1, r3);
CHECK_EQUAL(5, r4);
CHECK_EQUAL(6, r5);
size_t c1 = table->column().first.count("jennifer");
CHECK_EQUAL(2, c1);
// Serialize to memory (we now own the buffer)
BinaryData buffer = to_mem.write_to_mem();
// Load the table
Group from_mem(buffer);
TestTableGroup::Ref t = from_mem.get_table<TestTableGroup>("test");
CHECK_EQUAL(4, t->get_column_count());
CHECK_EQUAL(8, t->size());
CHECK(t->column().first.has_index());
size_t m1 = table->column().first.find_first("jimmi");
CHECK_EQUAL(not_found, m1);
size_t m2 = t->column().first.find_first("jeff");
size_t m3 = t->column().first.find_first("jim");
size_t m4 = t->column().first.find_first("jimbo");
size_t m5 = t->column().first.find_first("johnny");
CHECK_EQUAL(0, m2);
CHECK_EQUAL(1, m3);
CHECK_EQUAL(5, m4);
CHECK_EQUAL(6, m5);
size_t m6 = t->column().first.count("jennifer");
CHECK_EQUAL(2, m6);
}
TEST(Group_Stock_Bug)
{
// This test is a regression test - it once triggered a bug.
// the bug was fixed in pr 351. In release mode, it crashes
// the application. To get an assert in debug mode, the max
// list size should be set to 1000.
File::try_remove("test.tightdb");
Group group("test.tightdb", Group::mode_ReadWrite);
TableRef table = group.get_table("stocks");
table->add_column(type_String, "ticker");
for (size_t i = 0; i < 100; ++i) {
table->Verify();
table->insert_string(0, i, "123456789012345678901234567890123456789");
table->insert_done();
table->Verify();
group.commit();
}
}
#ifdef TIGHTDB_DEBUG
#ifdef TIGHTDB_TO_DOT
TEST(Group_ToDot)
{
// Create group with one table
Group mygroup;
// Create table with all column types
TableRef table = mygroup.get_table("test");
DescriptorRef subdesc;
s.add_column(type_Int, "int");
s.add_column(type_Bool, "bool");
s.add_column(type_DateTime, "date");
s.add_column(type_String, "string");
s.add_column(type_String, "string_long");
s.add_column(type_String, "string_enum"); // becomes ColumnStringEnum
s.add_column(type_Binary, "binary");
s.add_column(type_Mixed, "mixed");
s.add_column(type_Table, "tables", &subdesc);
subdesc->add_column(type_Int, "sub_first");
subdesc->add_column(type_String, "sub_second");
// Add some rows
for (size_t i = 0; i < 15; ++i) {
table->insert_int(0, i, i);
table->insert_bool(1, i, (i % 2 ? true : false));
table->insert_datetime(2, i, 12345);
stringstream ss;
ss << "string" << i;
table->insert_string(3, i, ss.str().c_str());
ss << " very long string.........";
table->insert_string(4, i, ss.str().c_str());
switch (i % 3) {
case 0:
table->insert_string(5, i, "test1");
break;
case 1:
table->insert_string(5, i, "test2");
break;
case 2:
table->insert_string(5, i, "test3");
break;
}
table->insert_binary(6, i, "binary", 7);
switch (i % 3) {
case 0:
table->insert_mixed(7, i, false);
break;
case 1:
table->insert_mixed(7, i, (int64_t)i);
break;
case 2:
table->insert_mixed(7, i, "string");
break;
}
table->insert_subtable(8, i);
table->insert_done();
// Add sub-tables
if (i == 2) {
// To mixed column
table->set_mixed(7, i, Mixed(type_Table));
Table subtable = table->GetMixedTable(7, i);
Spec s = subtable->get_spec();
s.add_column(type_Int, "first");
s.add_column(type_String, "second");
subtable->UpdateFromSpec(s.get_ref());
subtable->insert_int(0, 0, 42);
subtable->insert_string(1, 0, "meaning");
subtable->insert_done();
// To table column
Table subtable2 = table->get_subtable(8, i);
subtable2->insert_int(0, 0, 42);
subtable2->insert_string(1, 0, "meaning");
subtable2->insert_done();
}
}
// We also want ColumnStringEnum's
table->optimize();
#if 1
// Write array graph to cout
stringstream ss;
mygroup.ToDot(ss);
cout << ss.str() << endl;
#endif
// Write array graph to file in dot format
ofstream fs("tightdb_graph.dot", ios::out | ios::binary);
if (!fs.is_open())
cout << "file open error " << strerror << endl;
mygroup.to_dot(fs);
fs.close();
}
#endif // TIGHTDB_TO_DOT
#endif // TIGHTDB_DEBUG
#endif // TEST_GROUP
|
#include "omnicore/rpcrawtx.h"
#include "omnicore/omnicore.h"
#include "omnicore/rpc.h"
#include "omnicore/rpctxobject.h"
#include "omnicore/rpcvalues.h"
#include "coins.h"
#include "core_io.h"
#include "primitives/transaction.h"
#include "rpcserver.h"
#include "sync.h"
#include "uint256.h"
#include "json/json_spirit_value.h"
#include <stdint.h>
#include <stdexcept>
#include <string>
extern CCriticalSection cs_main;
using mastercore::cs_tx_cache;
using mastercore::view;
using namespace json_spirit;
Value omni_decodetransaction(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw std::runtime_error(
"omni_decodetransaction \"rawtx\" ( \"prevtxs\" )\n"
"\nDecodes an Omni transaction.\n"
"\nIf the inputs of the transaction are not in the chain, then they must be provided, because "
"the transaction inputs are used to identify the sender of a transaction.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to decode\n"
"2. prevtxs (string, optional) a JSON array of transaction inputs (default: none)\n"
" [\n"
" {\n"
" \"txid\":\"hash\", (string, required) the transaction hash\n"
" \"vout\":n, (number, required) the output number\n"
" \"scriptPubKey\":\"hex\", (string, required) the output script\n"
" \"value\":n.nnnnnnnn (number, required) the output value\n"
" }\n"
" ,...\n"
" ]\n"
"\nResult:\n"
"{\n"
" \"txid\" : \"hash\", (string) the hex-encoded hash of the transaction\n"
" \"fee\" : \"n.nnnnnnnn\", (string) the transaction fee in bitcoins\n"
" \"sendingaddress\" : \"address\", (string) the Bitcoin address of the sender\n"
" \"referenceaddress\" : \"address\", (string) a Bitcoin address used as reference (if any)\n"
" \"ismine\" : true|false, (boolean) whether the transaction involes an address in the wallet\n"
" \"version\" : n, (number) the transaction version\n"
" \"type_int\" : n, (number) the transaction type as number\n"
" \"type\" : \"type\", (string) the transaction type as string\n"
" [...] (mixed) other transaction type specific properties\n"
"}\n"
"\nExamples:\n"
+ HelpExampleCli("omni_decodetransaction", "\"010000000163af14ce6d477e1c793507e32a5b7696288fa89705c0d02a3f66beb3c5b8afee0100000000ffffffff02ac020000000000004751210261ea979f6a06f9dafe00fb1263ea0aca959875a7073556a088cdfadcd494b3752102a3fd0a8a067e06941e066f78d930bfc47746f097fcd3f7ab27db8ddf37168b6b52ae22020000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\" \"[{\\\"txid\\\":\\\"eeafb8c5b3be663f2ad0c00597a88f2896765b2ae30735791c7e476dce14af63\\\",\\\"vout\\\":1,\\\"scriptPubKey\\\":\\\"76a9149084c0bd89289bc025d0264f7f23148fb683d56c88ac\\\",\\\"value\\\":0.0001123}]\"")
+ HelpExampleRpc("omni_decodetransaction", "\"010000000163af14ce6d477e1c793507e32a5b7696288fa89705c0d02a3f66beb3c5b8afee0100000000ffffffff02ac020000000000004751210261ea979f6a06f9dafe00fb1263ea0aca959875a7073556a088cdfadcd494b3752102a3fd0a8a067e06941e066f78d930bfc47746f097fcd3f7ab27db8ddf37168b6b52ae22020000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\", [{\"txid\":\"eeafb8c5b3be663f2ad0c00597a88f2896765b2ae30735791c7e476dce14af63\",\"vout\":1,\"scriptPubKey\":\"76a9149084c0bd89289bc025d0264f7f23148fb683d56c88ac\",\"value\":0.0001123}]")
);
CTransaction tx = ParseTransaction(params[0]);
// use a dummy coins view to store the user provided transaction inputs
CCoinsView viewDummyTemp;
CCoinsViewCache viewTemp(&viewDummyTemp);
if (params.size() > 1) {
std::vector<PrevTxsEntry> prevTxsParsed = ParsePrevTxs(params[1]);
InputsToView(prevTxsParsed, viewTemp);
}
Object txObj;
int populateResult = -3331;
{
LOCK2(cs_main, cs_tx_cache);
// temporarily switch global coins view cache for transaction inputs
std::swap(view, viewTemp);
// then get the results
populateResult = populateRPCTransactionObject(tx, 0, txObj);
// and restore the original, unpolluted coins view cache
std::swap(viewTemp, view);
}
if (populateResult != 0) PopulateFailure(populateResult);
return txObj;
}
Add RPCs to build raw Omni transactions
#include "omnicore/rpcrawtx.h"
#include "omnicore/createtx.h"
#include "omnicore/omnicore.h"
#include "omnicore/rpc.h"
#include "omnicore/rpctxobject.h"
#include "omnicore/rpcvalues.h"
#include "coins.h"
#include "core_io.h"
#include "primitives/transaction.h"
#include "pubkey.h"
#include "rpcserver.h"
#include "sync.h"
#include "uint256.h"
#include "json/json_spirit_value.h"
#include <stdint.h>
#include <stdexcept>
#include <string>
extern CCriticalSection cs_main;
using mastercore::cs_tx_cache;
using mastercore::view;
using namespace json_spirit;
Value omni_decodetransaction(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw std::runtime_error(
"omni_decodetransaction \"rawtx\" ( \"prevtxs\" )\n"
"\nDecodes an Omni transaction.\n"
"\nIf the inputs of the transaction are not in the chain, then they must be provided, because "
"the transaction inputs are used to identify the sender of a transaction.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to decode\n"
"2. prevtxs (string, optional) a JSON array of transaction inputs (default: none)\n"
" [\n"
" {\n"
" \"txid\":\"hash\", (string, required) the transaction hash\n"
" \"vout\":n, (number, required) the output number\n"
" \"scriptPubKey\":\"hex\", (string, required) the output script\n"
" \"value\":n.nnnnnnnn (number, required) the output value\n"
" }\n"
" ,...\n"
" ]\n"
"\nResult:\n"
"{\n"
" \"txid\" : \"hash\", (string) the hex-encoded hash of the transaction\n"
" \"fee\" : \"n.nnnnnnnn\", (string) the transaction fee in bitcoins\n"
" \"sendingaddress\" : \"address\", (string) the Bitcoin address of the sender\n"
" \"referenceaddress\" : \"address\", (string) a Bitcoin address used as reference (if any)\n"
" \"ismine\" : true|false, (boolean) whether the transaction involes an address in the wallet\n"
" \"version\" : n, (number) the transaction version\n"
" \"type_int\" : n, (number) the transaction type as number\n"
" \"type\" : \"type\", (string) the transaction type as string\n"
" [...] (mixed) other transaction type specific properties\n"
"}\n"
"\nExamples:\n"
+ HelpExampleCli("omni_decodetransaction", "\"010000000163af14ce6d477e1c793507e32a5b7696288fa89705c0d02a3f66beb3c5b8afee0100000000ffffffff02ac020000000000004751210261ea979f6a06f9dafe00fb1263ea0aca959875a7073556a088cdfadcd494b3752102a3fd0a8a067e06941e066f78d930bfc47746f097fcd3f7ab27db8ddf37168b6b52ae22020000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\" \"[{\\\"txid\\\":\\\"eeafb8c5b3be663f2ad0c00597a88f2896765b2ae30735791c7e476dce14af63\\\",\\\"vout\\\":1,\\\"scriptPubKey\\\":\\\"76a9149084c0bd89289bc025d0264f7f23148fb683d56c88ac\\\",\\\"value\\\":0.0001123}]\"")
+ HelpExampleRpc("omni_decodetransaction", "\"010000000163af14ce6d477e1c793507e32a5b7696288fa89705c0d02a3f66beb3c5b8afee0100000000ffffffff02ac020000000000004751210261ea979f6a06f9dafe00fb1263ea0aca959875a7073556a088cdfadcd494b3752102a3fd0a8a067e06941e066f78d930bfc47746f097fcd3f7ab27db8ddf37168b6b52ae22020000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\", [{\"txid\":\"eeafb8c5b3be663f2ad0c00597a88f2896765b2ae30735791c7e476dce14af63\",\"vout\":1,\"scriptPubKey\":\"76a9149084c0bd89289bc025d0264f7f23148fb683d56c88ac\",\"value\":0.0001123}]")
);
CTransaction tx = ParseTransaction(params[0]);
// use a dummy coins view to store the user provided transaction inputs
CCoinsView viewDummyTemp;
CCoinsViewCache viewTemp(&viewDummyTemp);
if (params.size() > 1) {
std::vector<PrevTxsEntry> prevTxsParsed = ParsePrevTxs(params[1]);
InputsToView(prevTxsParsed, viewTemp);
}
Object txObj;
int populateResult = -3331;
{
LOCK2(cs_main, cs_tx_cache);
// temporarily switch global coins view cache for transaction inputs
std::swap(view, viewTemp);
// then get the results
populateResult = populateRPCTransactionObject(tx, 0, txObj);
// and restore the original, unpolluted coins view cache
std::swap(viewTemp, view);
}
if (populateResult != 0) PopulateFailure(populateResult);
return txObj;
}
Value omni_createrawtx_opreturn(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 2)
throw std::runtime_error(
"omni_createrawtx_opreturn \"rawtx\" \"payload\"\n"
"\nAdds a payload with class C (op-return) encoding to the transaction.\n"
"\nIf no raw transaction is provided, a new transaction is created.\n"
"\nIf the data encoding fails, then the transaction is not modified.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to extend (can be null)\n"
"2. payload (string, required) the hex-encoded payload to add\n"
"\nResult:\n"
"\"rawtx\" (string) the hex-encoded modified raw transaction\n"
"\nExamples\n"
+ HelpExampleCli("omni_createrawtx_opreturn", "\"01000000000000000000\" \"00000000000000020000000006dac2c0\"")
+ HelpExampleRpc("omni_createrawtx_opreturn", "\"01000000000000000000\", \"00000000000000020000000006dac2c0\"")
);
CMutableTransaction tx = ParseMutableTransaction(params[0]);
std::vector<unsigned char> payload = ParseHexV(params[1], "payload");
// extend the transaction
tx = OmniTxBuilder(tx)
.addOpReturn(payload)
.build();
return EncodeHexTx(tx);
}
Value omni_createrawtx_multisig(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 4)
throw std::runtime_error(
"omni_createrawtx_multisig \"rawtx\" \"payload\" \"seed\" \"redeemkey\"\n"
"\nAdds a payload with class B (bare-multisig) encoding to the transaction.\n"
"\nIf no raw transaction is provided, a new transaction is created.\n"
"\nIf the data encoding fails, then the transaction is not modified.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to extend (can be null)\n"
"2. payload (string, required) the hex-encoded payload to add\n"
"3. seed (string, required) the seed for obfuscation\n"
"4. redeemkey (string, required) a public key or address for dust redemption\n"
"\nResult:\n"
"\"rawtx\" (string) the hex-encoded modified raw transaction\n"
"\nExamples\n"
+ HelpExampleCli("omni_createrawtx_multisig", "\"0100000001a7a9402ecd77f3c9f745793c9ec805bfa2e14b89877581c734c774864247e6f50400000000ffffffff01aa0a0000000000001976a9146d18edfe073d53f84dd491dae1379f8fb0dfe5d488ac00000000\" \"00000000000000020000000000989680\" \"1LifmeXYHeUe2qdKWBGVwfbUCMMrwYtoMm\" \"0252ce4bdd3ce38b4ebbc5a6e1343608230da508ff12d23d85b58c964204c4cef3\"")
+ HelpExampleRpc("omni_createrawtx_multisig", "\"0100000001a7a9402ecd77f3c9f745793c9ec805bfa2e14b89877581c734c774864247e6f50400000000ffffffff01aa0a0000000000001976a9146d18edfe073d53f84dd491dae1379f8fb0dfe5d488ac00000000\", \"00000000000000020000000000989680\", \"1LifmeXYHeUe2qdKWBGVwfbUCMMrwYtoMm\", \"0252ce4bdd3ce38b4ebbc5a6e1343608230da508ff12d23d85b58c964204c4cef3\"")
);
CMutableTransaction tx = ParseMutableTransaction(params[0]);
std::vector<unsigned char> payload = ParseHexV(params[1], "payload");
std::string obfuscationSeed = ParseAddressOrEmpty(params[2]);
CPubKey redeemKey = ParsePubKeyOrAddress(params[3]);
// extend the transaction
tx = OmniTxBuilder(tx)
.addMultisig(payload, obfuscationSeed, redeemKey)
.build();
return EncodeHexTx(tx);
}
Value omni_createrawtx_input(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 3)
throw std::runtime_error(
"omni_createrawtx_input \"rawtx\" \"txid\" n\n"
"\nAdds a transaction input to the transaction.\n"
"\nIf no raw transaction is provided, a new transaction is created.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to extend (can be null)\n"
"2. txid (string, required) the hash of the input transaction\n"
"3. n (number, required) the index of the transaction output used as input\n"
"\nResult:\n"
"\"rawtx\" (string) the hex-encoded modified raw transaction\n"
"\nExamples\n"
+ HelpExampleCli("omni_createrawtx_input", "\"01000000000000000000\" \"b006729017df05eda586df9ad3f8ccfee5be340aadf88155b784d1fc0e8342ee\" 0")
+ HelpExampleRpc("omni_createrawtx_input", "\"01000000000000000000\", \"b006729017df05eda586df9ad3f8ccfee5be340aadf88155b784d1fc0e8342ee\", 0")
);
CMutableTransaction tx = ParseMutableTransaction(params[0]);
uint256 txid = ParseHashV(params[1], "txid");
uint32_t nOut = ParseOutputIndex(params[2]);
// extend the transaction
tx = OmniTxBuilder(tx)
.addInput(txid, nOut)
.build();
return EncodeHexTx(tx);
}
Value omni_createrawtx_reference(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 2 || params.size() > 3)
throw std::runtime_error(
"omni_createrawtx_reference \"rawtx\" \"destination\" ( amount )\n"
"\nAdds a reference output to the transaction.\n"
"\nIf no raw transaction is provided, a new transaction is created.\n"
"\nThe output value is set to at least the dust threshold.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to extend (can be null)\n"
"2. destination (string, required) the reference address or destination\n"
"3. amount (number, optional) the optional reference amount (minimal by default)\n"
"\nResult:\n"
"\"rawtx\" (string) the hex-encoded modified raw transaction\n"
"\nExamples\n"
+ HelpExampleCli("omni_createrawtx_reference", "\"0100000001a7a9402ecd77f3c9f745793c9ec805bfa2e14b89877581c734c774864247e6f50400000000ffffffff03aa0a0000000000001976a9146d18edfe073d53f84dd491dae1379f8fb0dfe5d488ac5c0d0000000000004751210252ce4bdd3ce38b4ebbc5a6e1343608230da508ff12d23d85b58c964204c4cef3210294cc195fc096f87d0f813a337ae7e5f961b1c8a18f1f8604a909b3a5121f065b52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\" \"1CE8bBr1dYZRMnpmyYsFEoexa1YoPz2mfB\" 0.005")
+ HelpExampleRpc("omni_createrawtx_reference", "\"0100000001a7a9402ecd77f3c9f745793c9ec805bfa2e14b89877581c734c774864247e6f50400000000ffffffff03aa0a0000000000001976a9146d18edfe073d53f84dd491dae1379f8fb0dfe5d488ac5c0d0000000000004751210252ce4bdd3ce38b4ebbc5a6e1343608230da508ff12d23d85b58c964204c4cef3210294cc195fc096f87d0f813a337ae7e5f961b1c8a18f1f8604a909b3a5121f065b52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\", \"1CE8bBr1dYZRMnpmyYsFEoexa1YoPz2mfB\", 0.005")
);
CMutableTransaction tx = ParseMutableTransaction(params[0]);
std::string destination = ParseAddress(params[1]);
int64_t amount = (params.size() > 2) ? AmountFromValue(params[2]) : 0;
// extend the transaction
tx = OmniTxBuilder(tx)
.addReference(destination, amount)
.build();
return EncodeHexTx(tx);
}
Value omni_createrawtx_change(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 4 || params.size() > 5)
throw std::runtime_error(
"omni_createrawtx_change \"rawtx\" \"prevtxs\" \"destination\" fee ( position )\n"
"\nAdds a change output to the transaction.\n"
"\nThe provided inputs are not added to the transaction, but only used to "
"determine the change. It is assumed that the inputs were previously added, "
"for example via \"createrawtransaction\".\n"
"\nOptionally a position can be provided, where the change output should be "
"inserted, starting with 0. If the number of outputs is smaller than the position, "
"then the change output is added to the end. Change outputs should be inserted "
"before reference outputs, and as per default, the change output is added to the "
"first position.\n"
"\nIf the change amount would be considered as dust, then no change output is added.\n"
"\nArguments:\n"
"1. rawtx (string, required) the raw transaction to extend\n"
"2. prevtxs (string, required) a JSON array of transaction inputs\n"
" [\n"
" {\n"
" \"txid\":\"hash\", (string, required) the transaction hash\n"
" \"vout\":n, (number, required) the output number\n"
" \"scriptPubKey\":\"hex\", (string, required) the output script\n"
" \"value\":n.nnnnnnnn (number, required) the output value\n"
" }\n"
" ,...\n"
" ]\n"
"3. destination (string, required) the destination for the change\n"
"4. fee (number, required) the desired transaction fees\n"
"5. position (number, optional) the position of the change output (default: first position)\n"
"\nResult:\n"
"\"rawtx\" (string) the hex-encoded modified raw transaction\n"
"\nExamples\n"
+ HelpExampleCli("omni_createrawtx_change", "\"0100000001b15ee60431ef57ec682790dec5a3c0d83a0c360633ea8308fbf6d5fc10a779670400000000ffffffff025c0d00000000000047512102f3e471222bb57a7d416c82bf81c627bfcd2bdc47f36e763ae69935bba4601ece21021580b888ff56feb27f17f08802ebed26258c23697d6a462d43fc13b565fda2dd52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\" \"[{\\\"txid\\\":\\\"6779a710fcd5f6fb0883ea3306360c3ad8c0a3c5de902768ec57ef3104e65eb1\\\",\\\"vout\\\":4,\\\"scriptPubKey\\\":\\\"76a9147b25205fd98d462880a3e5b0541235831ae959e588ac\\\",\\\"value\\\":0.00068257}]\" \"1CE8bBr1dYZRMnpmyYsFEoexa1YoPz2mfB\" 0.00003500 1")
+ HelpExampleRpc("omni_createrawtx_change", "\"0100000001b15ee60431ef57ec682790dec5a3c0d83a0c360633ea8308fbf6d5fc10a779670400000000ffffffff025c0d00000000000047512102f3e471222bb57a7d416c82bf81c627bfcd2bdc47f36e763ae69935bba4601ece21021580b888ff56feb27f17f08802ebed26258c23697d6a462d43fc13b565fda2dd52aeaa0a0000000000001976a914946cb2e08075bcbaf157e47bcb67eb2b2339d24288ac00000000\", [{\"txid\":\"6779a710fcd5f6fb0883ea3306360c3ad8c0a3c5de902768ec57ef3104e65eb1\",\"vout\":4,\"scriptPubKey\":\"76a9147b25205fd98d462880a3e5b0541235831ae959e588ac\",\"value\":0.00068257}], \"1CE8bBr1dYZRMnpmyYsFEoexa1YoPz2mfB\", 0.00003500, 1")
);
CMutableTransaction tx = ParseMutableTransaction(params[0]);
std::vector<PrevTxsEntry> prevTxsParsed = ParsePrevTxs(params[1]);
std::string destination = ParseAddress(params[2]);
int64_t txFee = AmountFromValue(params[3]);
uint32_t nOut = params.size() > 4 ? params[4].get_uint64() : 0;
// use a dummy coins view to store the user provided transaction inputs
CCoinsView viewDummy;
CCoinsViewCache viewTemp(&viewDummy);
InputsToView(prevTxsParsed, viewTemp);
// extend the transaction
tx = OmniTxBuilder(tx)
.addChange(destination, viewTemp, txFee, nOut)
.build();
return EncodeHexTx(tx);
}
|
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "views/examples/radio_button_example.h"
#include "base/stringprintf.h"
#include "base/utf_string_conversions.h"
#include "views/controls/button/text_button.h"
#include "views/layout/grid_layout.h"
#include "views/view.h"
namespace examples {
RadioButtonExample::RadioButtonExample(ExamplesMain* main)
: ExampleBase(main, "Radio Button"), count_(0) {
}
RadioButtonExample::~RadioButtonExample() {
}
void RadioButtonExample::CreateExampleView(views::View* container) {
select_ = new views::TextButton(this, L"Select");
status_ = new views::TextButton(this, L"Show Status");
int group = 1;
for (size_t i = 0; i < arraysize(radio_buttons_); ++i) {
radio_buttons_[i] = new views::RadioButton(
UTF8ToUTF16(base::StringPrintf("Radio %d in group %d", i + 1, group)),
group);
radio_buttons_[i]->set_listener(this);
}
views::GridLayout* layout = new views::GridLayout(container);
container->SetLayoutManager(layout);
views::ColumnSet* column_set = layout->AddColumnSet(0);
column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL,
1.0f, views::GridLayout::USE_PREF, 0, 0);
for (size_t i = 0; i < arraysize(radio_buttons_); ++i) {
layout->StartRow(0, 0);
layout->AddView(radio_buttons_[i]);
}
layout->StartRow(0, 0);
layout->AddView(select_);
layout->StartRow(0, 0);
layout->AddView(status_);
}
void RadioButtonExample::ButtonPressed(views::Button* sender,
const views::Event& event) {
if (sender == select_) {
radio_buttons_[2]->SetChecked(true);
} else if (sender == status_) {
// Show the state of radio buttons.
PrintStatus("Group: 1:%s, 2:%s, 3:%s",
BoolToOnOff(radio_buttons_[0]->checked()),
BoolToOnOff(radio_buttons_[1]->checked()),
BoolToOnOff(radio_buttons_[2]->checked()));
} else {
PrintStatus("Pressed! count:%d", ++count_);
}
}
} // namespace examples
views/examples: Fix the format string of size_t var in RadioButton example.
Cast from size_t to int.
TEST=compile views_examples target, it should work without errors.
R=sky@chromium.org
Review URL: http://codereview.chromium.org/8252009
git-svn-id: de016e52bd170d2d4f2344f9bf92d50478b649e0@105584 0039d316-1c4b-4281-b951-d872f2087c98
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "views/examples/radio_button_example.h"
#include "base/stringprintf.h"
#include "base/utf_string_conversions.h"
#include "views/controls/button/text_button.h"
#include "views/layout/grid_layout.h"
#include "views/view.h"
namespace examples {
RadioButtonExample::RadioButtonExample(ExamplesMain* main)
: ExampleBase(main, "Radio Button"), count_(0) {
}
RadioButtonExample::~RadioButtonExample() {
}
void RadioButtonExample::CreateExampleView(views::View* container) {
select_ = new views::TextButton(this, L"Select");
status_ = new views::TextButton(this, L"Show Status");
int group = 1;
for (size_t i = 0; i < arraysize(radio_buttons_); ++i) {
radio_buttons_[i] = new views::RadioButton(
UTF8ToUTF16(base::StringPrintf(
"Radio %d in group %d", static_cast<int>(i) + 1, group)),
group);
radio_buttons_[i]->set_listener(this);
}
views::GridLayout* layout = new views::GridLayout(container);
container->SetLayoutManager(layout);
views::ColumnSet* column_set = layout->AddColumnSet(0);
column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL,
1.0f, views::GridLayout::USE_PREF, 0, 0);
for (size_t i = 0; i < arraysize(radio_buttons_); ++i) {
layout->StartRow(0, 0);
layout->AddView(radio_buttons_[i]);
}
layout->StartRow(0, 0);
layout->AddView(select_);
layout->StartRow(0, 0);
layout->AddView(status_);
}
void RadioButtonExample::ButtonPressed(views::Button* sender,
const views::Event& event) {
if (sender == select_) {
radio_buttons_[2]->SetChecked(true);
} else if (sender == status_) {
// Show the state of radio buttons.
PrintStatus("Group: 1:%s, 2:%s, 3:%s",
BoolToOnOff(radio_buttons_[0]->checked()),
BoolToOnOff(radio_buttons_[1]->checked()),
BoolToOnOff(radio_buttons_[2]->checked()));
} else {
PrintStatus("Pressed! count:%d", ++count_);
}
}
} // namespace examples
|
/*
* Copyright 2007-2018 by the individuals mentioned in the source code history
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "omxData.h"
#include <Eigen/Core>
// #include <Eigen/Dense>
#include "EnableWarnings.h"
struct omxWLSFitFunction : omxFitFunction {
omxMatrix* observedCov;
omxMatrix* observedMeans;
omxMatrix* expectedCov;
omxMatrix* expectedMeans;
omxMatrix* observedFlattened;
omxMatrix* expectedFlattened;
omxMatrix* weights;
omxMatrix* P;
omxMatrix* B;
int n;
int fullWls;
int numOrdinal;
omxWLSFitFunction() :standardMeans(0), standardThresholds(0) {};
virtual ~omxWLSFitFunction();
virtual void init();
virtual void compute(int ffcompute, FitContext *fc);
virtual void populateAttr(SEXP algebra);
// 'standard' prefix variables are temp space used by flattenDataToVector
omxMatrix* standardCov;
omxMatrix* standardMeans;
omxMatrix* standardThresholds;
void flattenDataToVector(omxMatrix* cov, omxMatrix* means, omxMatrix *thresholdMat,
std::vector< omxThresholdColumn > &thresholds, omxMatrix* vector);
};
void omxWLSFitFunction::flattenDataToVector(omxMatrix* cov, omxMatrix* means, omxMatrix *thresholdMat,
std::vector< omxThresholdColumn > &thresholds, omxMatrix* vector)
{
EigenVectorAdaptor vec1(vector);
normalToStdVector(cov, means, thresholdMat, numOrdinal, thresholds, vec1);
}
omxWLSFitFunction::~omxWLSFitFunction()
{
if(OMX_DEBUG) {mxLog("Freeing WLS FitFunction.");}
omxWLSFitFunction* owo = this;
omxFreeMatrix(owo->observedFlattened);
omxFreeMatrix(owo->expectedFlattened);
omxFreeMatrix(owo->B);
omxFreeMatrix(owo->P);
omxFreeMatrix(owo->standardCov);
omxFreeMatrix(owo->standardMeans);
omxFreeMatrix(owo->standardThresholds);
}
void omxWLSFitFunction::compute(int want, FitContext *fc)
{
auto *oo = this;
auto *owo = this;
if (want & (FF_COMPUTE_INITIAL_FIT | FF_COMPUTE_PREOPTIMIZE)) return;
if(OMX_DEBUG) { mxLog("Beginning WLS Evaluation.");}
// Requires: Data, means, covariances.
double sum = 0.0;
omxMatrix *eCov, *eMeans, *oFlat, *eFlat;
/* Locals for readability. Compiler should cut through this. */
eCov = owo->expectedCov;
eMeans = owo->expectedMeans;
auto &eThresh = oo->expectation->getThresholdInfo();
oFlat = owo->observedFlattened;
eFlat = owo->expectedFlattened;
int onei = 1;
/* Recompute and recopy */
if(OMX_DEBUG) { mxLog("WLSFitFunction Computing expectation"); }
omxExpectationCompute(fc, expectation, NULL);
omxMatrix *expThresholdsMat = expectation->thresholdsMat;
flattenDataToVector(eCov, eMeans, expThresholdsMat, eThresh, eFlat);
omxCopyMatrix(B, oFlat);
//if(OMX_DEBUG) {omxPrintMatrix(B, "....WLS Observed Vector: "); }
if(OMX_DEBUG) {omxPrintMatrix(eFlat, "....WLS Expected Vector: "); }
omxDAXPY(-1.0, eFlat, B);
//if(OMX_DEBUG) {omxPrintMatrix(B, "....WLS Observed - Expected Vector: "); }
if(weights != NULL) {
//if(OMX_DEBUG_ALGEBRA) {omxPrintMatrix(weights, "....WLS Weight Matrix: "); }
omxDGEMV(TRUE, 1.0, weights, B, 0.0, P);
} else {
// ULS Case: Memcpy faster than dgemv.
omxCopyMatrix(P, B);
}
sum = F77_CALL(ddot)(&(P->cols), P->data, &onei, B->data, &onei);
oo->matrix->data[0] = sum;
if(OMX_DEBUG) { mxLog("WLSFitFunction value comes to: %f.", oo->matrix->data[0]); }
}
void omxWLSFitFunction::populateAttr(SEXP algebra)
{
if(OMX_DEBUG) { mxLog("Populating WLS Attributes."); }
omxWLSFitFunction *argStruct = this;
omxMatrix *expCovInt = argStruct->expectedCov; // Expected covariance
omxMatrix *expMeanInt = argStruct->expectedMeans; // Expected means
omxMatrix *weightInt = argStruct->weights; // Expected means
SEXP expCovExt, expMeanExt, gradients;
Rf_protect(expCovExt = Rf_allocMatrix(REALSXP, expCovInt->rows, expCovInt->cols));
for(int row = 0; row < expCovInt->rows; row++)
for(int col = 0; col < expCovInt->cols; col++)
REAL(expCovExt)[col * expCovInt->rows + row] =
omxMatrixElement(expCovInt, row, col);
if (expMeanInt != NULL) {
Rf_protect(expMeanExt = Rf_allocMatrix(REALSXP, expMeanInt->rows, expMeanInt->cols));
for(int row = 0; row < expMeanInt->rows; row++)
for(int col = 0; col < expMeanInt->cols; col++)
REAL(expMeanExt)[col * expMeanInt->rows + row] =
omxMatrixElement(expMeanInt, row, col);
} else {
Rf_protect(expMeanExt = Rf_allocMatrix(REALSXP, 0, 0));
}
if(OMX_DEBUG_ALGEBRA) {omxPrintMatrix(weightInt, "...WLS Weight Matrix: W"); }
SEXP weightExt = NULL;
if (weightInt) {
Rf_protect(weightExt = Rf_allocMatrix(REALSXP, weightInt->rows, weightInt->cols));
for(int row = 0; row < weightInt->rows; row++)
for(int col = 0; col < weightInt->cols; col++)
REAL(weightExt)[col * weightInt->rows + row] = weightInt->data[col * weightInt->rows + row];
}
if(0) { /* TODO fix for new internal API
int nLocs = Global->numFreeParams;
double gradient[Global->numFreeParams];
for(int loc = 0; loc < nLocs; loc++) {
gradient[loc] = NA_REAL;
}
//oo->gradientFun(oo, gradient);
Rf_protect(gradients = Rf_allocMatrix(REALSXP, 1, nLocs));
for(int loc = 0; loc < nLocs; loc++)
REAL(gradients)[loc] = gradient[loc];
*/
} else {
Rf_protect(gradients = Rf_allocMatrix(REALSXP, 0, 0));
}
if(OMX_DEBUG) { mxLog("Installing populated WLS Attributes."); }
Rf_setAttrib(algebra, Rf_install("expCov"), expCovExt);
Rf_setAttrib(algebra, Rf_install("expMean"), expMeanExt);
if (weightExt) Rf_setAttrib(algebra, Rf_install("weights"), weightExt);
Rf_setAttrib(algebra, Rf_install("gradients"), gradients);
ProtectedSEXP Rsat(Rf_ScalarReal(0));
Rf_setAttrib(algebra, Rf_install("SaturatedLikelihood"), Rsat);
//Rf_setAttrib(algebra, Rf_install("IndependenceLikelihood"), Rf_ScalarReal(0));
ProtectedSEXP Rmisfit(Rf_ScalarReal(omxMatrixElement(matrix, 0, 0)));
Rf_setAttrib(algebra, Rf_install("ADFMisfit"), Rmisfit);
}
omxFitFunction *omxInitWLSFitFunction()
{ return new omxWLSFitFunction; }
void omxWLSFitFunction::init()
{
auto *oo = this;
auto *newObj = this;
omxState *currentState = oo->matrix->currentState;
omxMatrix *cov, *means;
if(OMX_DEBUG) { mxLog("Initializing WLS FitFunction function."); }
if(OMX_DEBUG) { mxLog("Retrieving expectation.\n"); }
if (!oo->expectation) { Rf_error("%s requires an expectation", oo->fitType); }
if(OMX_DEBUG) { mxLog("Retrieving data.\n"); }
omxData* dataMat = oo->expectation->data;
if (dataMat->hasDefinitionVariables()) Rf_error("%s: def vars not implemented", oo->name());
if(!strEQ(omxDataType(dataMat), "acov") && !strEQ(omxDataType(dataMat), "cov")) {
char *errstr = (char*) calloc(250, sizeof(char));
sprintf(errstr, "WLS FitFunction unable to handle data type %s. Data must be of type 'acov'.\n", omxDataType(dataMat));
omxRaiseError(errstr);
free(errstr);
if(OMX_DEBUG) { mxLog("WLS FitFunction unable to handle data type %s. Aborting.", omxDataType(dataMat)); }
return;
}
fullWls = strEQ("WLS", CHAR(Rf_asChar(R_do_slot(rObj, Rf_install("weights")))));
oo->units = fullWls? FIT_UNITS_SQUARED_RESIDUAL_CHISQ : FIT_UNITS_SQUARED_RESIDUAL;
/* Get Expectation Elements */
newObj->expectedCov = omxGetExpectationComponent(oo->expectation, "cov");
newObj->expectedMeans = omxGetExpectationComponent(oo->expectation, "means");
/* Read and set expected means, variances, and weights */
dataMat->permute(oo->expectation->getDataColumns());
cov = omxDataCovariance(dataMat);
means = omxDataMeans(dataMat);
weights = omxDataAcov(dataMat);
std::vector< omxThresholdColumn > &oThresh = omxDataThresholds(oo->expectation->data);
newObj->observedCov = cov;
newObj->observedMeans = means;
newObj->n = omxDataNumObs(dataMat);
numOrdinal = oo->expectation->numOrdinal;
auto &eThresh = oo->expectation->getThresholdInfo();
if (eThresh.size() && !means) {
omxRaiseError("Means are required when the data include ordinal measurements");
return;
}
// Error Checking: Observed/Expected means must agree.
// ^ is XOR: true when one is false and the other is not.
if((newObj->expectedMeans == NULL) ^ (newObj->observedMeans == NULL)) {
if(newObj->expectedMeans != NULL) {
omxRaiseError("Observed means not detected, but an expected means matrix was specified.\n If you wish to model the means, you must provide observed means.\n");
return;
} else {
omxRaiseError("Observed means were provided, but an expected means matrix was not specified.\n If you provide observed means, you must specify a model for the means.\n");
return;
}
}
if((eThresh.size()==0) ^ (oThresh.size()==0)) {
if (eThresh.size()) {
omxRaiseError("Observed thresholds not detected, but an expected thresholds matrix was specified.\n If you wish to model the thresholds, you must provide observed thresholds.\n ");
return;
} else {
omxRaiseError("Observed thresholds were provided, but an expected thresholds matrix was not specified.\nIf you provide observed thresholds, you must specify a model for the thresholds.\n");
return;
}
}
for(int i = 0, ei=0; i < int(oThresh.size()); i++) {
while (ei < int(eThresh.size()) && eThresh[ei].dColumn != oThresh[i].dColumn) ++ei;
eThresh[ei].numThresholds = oThresh[i].numThresholds;
}
if (OMX_DEBUG) {
mxLog("expected thresholds:");
for (auto &th : eThresh) { th.log(); }
mxLog("observed thresholds:");
for (auto &th : oThresh) { th.log(); }
}
/* Error check weight matrix size */
int ncol = newObj->observedCov->cols;
int vectorSize = expectation->numSummaryStats();
if(OMX_DEBUG) { mxLog("Intial WLSFitFunction vectorSize comes to: %d.", vectorSize); }
if(weights != NULL && (weights->rows != weights->cols || weights->cols != vectorSize)) {
omxRaiseError("Developer Error in WLS-based FitFunction object: WLS-based expectation specified an incorrectly-sized weight matrix.\nIf you are not developing a new expectation type, you should probably post this to the OpenMx forums.");
return;
}
// FIXME: More Rf_error checking for incoming Fit Functions
/* Temporary storage for calculation */
newObj->observedFlattened = omxInitMatrix(vectorSize, 1, TRUE, currentState);
newObj->expectedFlattened = omxInitMatrix(vectorSize, 1, TRUE, currentState);
newObj->P = omxInitMatrix(1, vectorSize, TRUE, currentState);
newObj->B = omxInitMatrix(vectorSize, 1, TRUE, currentState);
newObj->standardCov = omxInitMatrix(ncol, ncol, TRUE, currentState);
if (oo->expectation->thresholdsMat) {
newObj->standardThresholds = omxInitMatrix(oo->expectation->thresholdsMat->rows, oo->expectation->thresholdsMat->cols, TRUE, currentState);
}
if(means){
newObj->standardMeans = omxInitMatrix(1, ncol, TRUE, currentState);
}
omxMatrix *obsThresholdsMat = oo->expectation->data->obsThresholdsMat;
if (obsThresholdsMat && oo->expectation->thresholdsMat) {
if (obsThresholdsMat->rows != oo->expectation->thresholdsMat->rows ||
obsThresholdsMat->cols != oo->expectation->thresholdsMat->cols) {
omxRaiseError("Observed and expected threshold matrices must have the same number of rows and columns");
}
}
flattenDataToVector(newObj->observedCov, newObj->observedMeans, obsThresholdsMat, oThresh, newObj->observedFlattened);
flattenDataToVector(newObj->expectedCov, newObj->expectedMeans, oo->expectation->thresholdsMat,
eThresh, newObj->expectedFlattened);
}
Remove deadcode
/*
* Copyright 2007-2018 by the individuals mentioned in the source code history
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "omxData.h"
#include <Eigen/Core>
// #include <Eigen/Dense>
#include "EnableWarnings.h"
struct omxWLSFitFunction : omxFitFunction {
omxMatrix* expectedCov;
omxMatrix* expectedMeans;
omxMatrix* observedFlattened;
omxMatrix* expectedFlattened;
omxMatrix* weights;
omxMatrix* P;
omxMatrix* B;
int n;
int fullWls;
int numOrdinal;
omxWLSFitFunction() :standardMeans(0), standardThresholds(0) {};
virtual ~omxWLSFitFunction();
virtual void init();
virtual void compute(int ffcompute, FitContext *fc);
virtual void populateAttr(SEXP algebra);
// 'standard' prefix variables are temp space used by flattenDataToVector
omxMatrix* standardCov;
omxMatrix* standardMeans;
omxMatrix* standardThresholds;
void flattenDataToVector(omxMatrix* cov, omxMatrix* means, omxMatrix *thresholdMat,
std::vector< omxThresholdColumn > &thresholds, omxMatrix* vector);
};
void omxWLSFitFunction::flattenDataToVector(omxMatrix* cov, omxMatrix* means, omxMatrix *thresholdMat,
std::vector< omxThresholdColumn > &thresholds, omxMatrix* vector)
{
EigenVectorAdaptor vec1(vector);
normalToStdVector(cov, means, thresholdMat, numOrdinal, thresholds, vec1);
}
omxWLSFitFunction::~omxWLSFitFunction()
{
if(OMX_DEBUG) {mxLog("Freeing WLS FitFunction.");}
omxWLSFitFunction* owo = this;
omxFreeMatrix(owo->observedFlattened);
omxFreeMatrix(owo->expectedFlattened);
omxFreeMatrix(owo->B);
omxFreeMatrix(owo->P);
omxFreeMatrix(owo->standardCov);
omxFreeMatrix(owo->standardMeans);
omxFreeMatrix(owo->standardThresholds);
}
void omxWLSFitFunction::compute(int want, FitContext *fc)
{
auto *oo = this;
auto *owo = this;
if (want & (FF_COMPUTE_INITIAL_FIT | FF_COMPUTE_PREOPTIMIZE)) return;
if(OMX_DEBUG) { mxLog("Beginning WLS Evaluation.");}
// Requires: Data, means, covariances.
double sum = 0.0;
omxMatrix *eCov, *eMeans, *oFlat, *eFlat;
/* Locals for readability. Compiler should cut through this. */
eCov = owo->expectedCov;
eMeans = owo->expectedMeans;
auto &eThresh = oo->expectation->getThresholdInfo();
oFlat = owo->observedFlattened;
eFlat = owo->expectedFlattened;
int onei = 1;
/* Recompute and recopy */
if(OMX_DEBUG) { mxLog("WLSFitFunction Computing expectation"); }
omxExpectationCompute(fc, expectation, NULL);
omxMatrix *expThresholdsMat = expectation->thresholdsMat;
flattenDataToVector(eCov, eMeans, expThresholdsMat, eThresh, eFlat);
omxCopyMatrix(B, oFlat);
//if(OMX_DEBUG) {omxPrintMatrix(B, "....WLS Observed Vector: "); }
if(OMX_DEBUG) {omxPrintMatrix(eFlat, "....WLS Expected Vector: "); }
omxDAXPY(-1.0, eFlat, B);
//if(OMX_DEBUG) {omxPrintMatrix(B, "....WLS Observed - Expected Vector: "); }
if(weights != NULL) {
//if(OMX_DEBUG_ALGEBRA) {omxPrintMatrix(weights, "....WLS Weight Matrix: "); }
omxDGEMV(TRUE, 1.0, weights, B, 0.0, P);
} else {
// ULS Case: Memcpy faster than dgemv.
omxCopyMatrix(P, B);
}
sum = F77_CALL(ddot)(&(P->cols), P->data, &onei, B->data, &onei);
oo->matrix->data[0] = sum;
if(OMX_DEBUG) { mxLog("WLSFitFunction value comes to: %f.", oo->matrix->data[0]); }
}
void omxWLSFitFunction::populateAttr(SEXP algebra)
{
if(OMX_DEBUG) { mxLog("Populating WLS Attributes."); }
omxWLSFitFunction *argStruct = this;
omxMatrix *expCovInt = argStruct->expectedCov; // Expected covariance
omxMatrix *expMeanInt = argStruct->expectedMeans; // Expected means
omxMatrix *weightInt = argStruct->weights; // Expected means
SEXP expCovExt, expMeanExt, gradients;
Rf_protect(expCovExt = Rf_allocMatrix(REALSXP, expCovInt->rows, expCovInt->cols));
for(int row = 0; row < expCovInt->rows; row++)
for(int col = 0; col < expCovInt->cols; col++)
REAL(expCovExt)[col * expCovInt->rows + row] =
omxMatrixElement(expCovInt, row, col);
if (expMeanInt != NULL) {
Rf_protect(expMeanExt = Rf_allocMatrix(REALSXP, expMeanInt->rows, expMeanInt->cols));
for(int row = 0; row < expMeanInt->rows; row++)
for(int col = 0; col < expMeanInt->cols; col++)
REAL(expMeanExt)[col * expMeanInt->rows + row] =
omxMatrixElement(expMeanInt, row, col);
} else {
Rf_protect(expMeanExt = Rf_allocMatrix(REALSXP, 0, 0));
}
if(OMX_DEBUG_ALGEBRA) {omxPrintMatrix(weightInt, "...WLS Weight Matrix: W"); }
SEXP weightExt = NULL;
if (weightInt) {
Rf_protect(weightExt = Rf_allocMatrix(REALSXP, weightInt->rows, weightInt->cols));
for(int row = 0; row < weightInt->rows; row++)
for(int col = 0; col < weightInt->cols; col++)
REAL(weightExt)[col * weightInt->rows + row] = weightInt->data[col * weightInt->rows + row];
}
if(0) { /* TODO fix for new internal API
int nLocs = Global->numFreeParams;
double gradient[Global->numFreeParams];
for(int loc = 0; loc < nLocs; loc++) {
gradient[loc] = NA_REAL;
}
//oo->gradientFun(oo, gradient);
Rf_protect(gradients = Rf_allocMatrix(REALSXP, 1, nLocs));
for(int loc = 0; loc < nLocs; loc++)
REAL(gradients)[loc] = gradient[loc];
*/
} else {
Rf_protect(gradients = Rf_allocMatrix(REALSXP, 0, 0));
}
if(OMX_DEBUG) { mxLog("Installing populated WLS Attributes."); }
Rf_setAttrib(algebra, Rf_install("expCov"), expCovExt);
Rf_setAttrib(algebra, Rf_install("expMean"), expMeanExt);
if (weightExt) Rf_setAttrib(algebra, Rf_install("weights"), weightExt);
Rf_setAttrib(algebra, Rf_install("gradients"), gradients);
ProtectedSEXP Rsat(Rf_ScalarReal(0));
Rf_setAttrib(algebra, Rf_install("SaturatedLikelihood"), Rsat);
//Rf_setAttrib(algebra, Rf_install("IndependenceLikelihood"), Rf_ScalarReal(0));
ProtectedSEXP Rmisfit(Rf_ScalarReal(omxMatrixElement(matrix, 0, 0)));
Rf_setAttrib(algebra, Rf_install("ADFMisfit"), Rmisfit);
}
omxFitFunction *omxInitWLSFitFunction()
{ return new omxWLSFitFunction; }
void omxWLSFitFunction::init()
{
auto *oo = this;
auto *newObj = this;
omxState *currentState = oo->matrix->currentState;
omxMatrix *cov, *means;
if(OMX_DEBUG) { mxLog("Initializing WLS FitFunction function."); }
if(OMX_DEBUG) { mxLog("Retrieving expectation.\n"); }
if (!oo->expectation) { Rf_error("%s requires an expectation", oo->fitType); }
if(OMX_DEBUG) { mxLog("Retrieving data.\n"); }
omxData* dataMat = oo->expectation->data;
if (dataMat->hasDefinitionVariables()) Rf_error("%s: def vars not implemented", oo->name());
if(!strEQ(omxDataType(dataMat), "acov") && !strEQ(omxDataType(dataMat), "cov")) {
char *errstr = (char*) calloc(250, sizeof(char));
sprintf(errstr, "WLS FitFunction unable to handle data type %s. Data must be of type 'acov'.\n", omxDataType(dataMat));
omxRaiseError(errstr);
free(errstr);
if(OMX_DEBUG) { mxLog("WLS FitFunction unable to handle data type %s. Aborting.", omxDataType(dataMat)); }
return;
}
fullWls = strEQ("WLS", CHAR(Rf_asChar(R_do_slot(rObj, Rf_install("weights")))));
oo->units = fullWls? FIT_UNITS_SQUARED_RESIDUAL_CHISQ : FIT_UNITS_SQUARED_RESIDUAL;
/* Get Expectation Elements */
newObj->expectedCov = omxGetExpectationComponent(oo->expectation, "cov");
newObj->expectedMeans = omxGetExpectationComponent(oo->expectation, "means");
/* Read and set expected means, variances, and weights */
dataMat->permute(oo->expectation->getDataColumns());
cov = omxDataCovariance(dataMat);
means = omxDataMeans(dataMat);
weights = omxDataAcov(dataMat);
std::vector< omxThresholdColumn > &oThresh = omxDataThresholds(oo->expectation->data);
newObj->n = omxDataNumObs(dataMat);
numOrdinal = oo->expectation->numOrdinal;
auto &eThresh = oo->expectation->getThresholdInfo();
if (eThresh.size() && !means) {
omxRaiseError("Means are required when the data include ordinal measurements");
return;
}
// Error Checking: Observed/Expected means must agree.
// ^ is XOR: true when one is false and the other is not.
if((newObj->expectedMeans == NULL) ^ (means == NULL)) {
if(newObj->expectedMeans != NULL) {
omxRaiseError("Observed means not detected, but an expected means matrix was specified.\n If you wish to model the means, you must provide observed means.\n");
return;
} else {
omxRaiseError("Observed means were provided, but an expected means matrix was not specified.\n If you provide observed means, you must specify a model for the means.\n");
return;
}
}
if((eThresh.size()==0) ^ (oThresh.size()==0)) {
if (eThresh.size()) {
omxRaiseError("Observed thresholds not detected, but an expected thresholds matrix was specified.\n If you wish to model the thresholds, you must provide observed thresholds.\n ");
return;
} else {
omxRaiseError("Observed thresholds were provided, but an expected thresholds matrix was not specified.\nIf you provide observed thresholds, you must specify a model for the thresholds.\n");
return;
}
}
for(int i = 0, ei=0; i < int(oThresh.size()); i++) {
while (ei < int(eThresh.size()) && eThresh[ei].dColumn != oThresh[i].dColumn) ++ei;
eThresh[ei].numThresholds = oThresh[i].numThresholds;
}
if (OMX_DEBUG) {
mxLog("expected thresholds:");
for (auto &th : eThresh) { th.log(); }
mxLog("observed thresholds:");
for (auto &th : oThresh) { th.log(); }
}
/* Error check weight matrix size */
int ncol = cov->cols;
int vectorSize = expectation->numSummaryStats();
if(OMX_DEBUG) { mxLog("Intial WLSFitFunction vectorSize comes to: %d.", vectorSize); }
if(weights != NULL && (weights->rows != weights->cols || weights->cols != vectorSize)) {
omxRaiseError("Developer Error in WLS-based FitFunction object: WLS-based expectation specified an incorrectly-sized weight matrix.\nIf you are not developing a new expectation type, you should probably post this to the OpenMx forums.");
return;
}
// FIXME: More Rf_error checking for incoming Fit Functions
/* Temporary storage for calculation */
newObj->observedFlattened = omxInitMatrix(vectorSize, 1, TRUE, currentState);
newObj->expectedFlattened = omxInitMatrix(vectorSize, 1, TRUE, currentState);
newObj->P = omxInitMatrix(1, vectorSize, TRUE, currentState);
newObj->B = omxInitMatrix(vectorSize, 1, TRUE, currentState);
newObj->standardCov = omxInitMatrix(ncol, ncol, TRUE, currentState);
if (oo->expectation->thresholdsMat) {
newObj->standardThresholds = omxInitMatrix(oo->expectation->thresholdsMat->rows, oo->expectation->thresholdsMat->cols, TRUE, currentState);
}
if(means){
newObj->standardMeans = omxInitMatrix(1, ncol, TRUE, currentState);
}
omxMatrix *obsThresholdsMat = oo->expectation->data->obsThresholdsMat;
if (obsThresholdsMat && oo->expectation->thresholdsMat) {
if (obsThresholdsMat->rows != oo->expectation->thresholdsMat->rows ||
obsThresholdsMat->cols != oo->expectation->thresholdsMat->cols) {
omxRaiseError("Observed and expected threshold matrices must have the same number of rows and columns");
}
}
flattenDataToVector(cov, means, obsThresholdsMat, oThresh, newObj->observedFlattened);
flattenDataToVector(newObj->expectedCov, newObj->expectedMeans, oo->expectation->thresholdsMat,
eThresh, newObj->expectedFlattened);
}
|
//===- ICF.cpp ------------------------------------------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// ICF is short for Identical Code Folding. This is a size optimization to
// identify and merge two or more read-only sections (typically functions)
// that happened to have the same contents. It usually reduces output size
// by a few percent.
//
// In ICF, two sections are considered identical if they have the same
// section flags, section data, and relocations. Relocations are tricky,
// because two relocations are considered the same if they have the same
// relocation types, values, and if they point to the same sections *in
// terms of ICF*.
//
// Here is an example. If foo and bar defined below are compiled to the
// same machine instructions, ICF can and should merge the two, although
// their relocations point to each other.
//
// void foo() { bar(); }
// void bar() { foo(); }
//
// If you merge the two, their relocations point to the same section and
// thus you know they are mergeable, but how do you know they are
// mergeable in the first place? This is not an easy problem to solve.
//
// What we are doing in LLD is to partition sections into equivalence
// classes. Sections in the same equivalence class when the algorithm
// terminates are considered identical. Here are details:
//
// 1. First, we partition sections using their hash values as keys. Hash
// values contain section types, section contents and numbers of
// relocations. During this step, relocation targets are not taken into
// account. We just put sections that apparently differ into different
// equivalence classes.
//
// 2. Next, for each equivalence class, we visit sections to compare
// relocation targets. Relocation targets are considered equivalent if
// their targets are in the same equivalence class. Sections with
// different relocation targets are put into different equivalence
// clases.
//
// 3. If we split an equivalence class in step 2, two relocations
// previously target the same equivalence class may now target
// different equivalence classes. Therefore, we repeat step 2 until a
// convergence is obtained.
//
// 4. For each equivalence class C, pick an arbitrary section in C, and
// merge all the other sections in C with it.
//
// For small programs, this algorithm needs 3-5 iterations. For large
// programs such as Chromium, it takes more than 20 iterations.
//
// This algorithm was mentioned as an "optimistic algorithm" in [1],
// though gold implements a different algorithm than this.
//
// We parallelize each step so that multiple threads can work on different
// equivalence classes concurrently. That gave us a large performance
// boost when applying ICF on large programs. For example, MSVC link.exe
// or GNU gold takes 10-20 seconds to apply ICF on Chromium, whose output
// size is about 1.5 GB, but LLD can finish it in less than 2 seconds on a
// 2.8 GHz 40 core machine. Even without threading, LLD's ICF is still
// faster than MSVC or gold though.
//
// [1] Safe ICF: Pointer Safe and Unwinding aware Identical Code Folding
// in the Gold Linker
// http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36912.pdf
//
//===----------------------------------------------------------------------===//
#include "ICF.h"
#include "Config.h"
#include "SymbolTable.h"
#include "Symbols.h"
#include "lld/Common/Threads.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/Object/ELF.h"
#include <algorithm>
#include <atomic>
using namespace lld;
using namespace lld::elf;
using namespace llvm;
using namespace llvm::ELF;
using namespace llvm::object;
namespace {
template <class ELFT> class ICF {
public:
void run();
private:
void segregate(size_t Begin, size_t End, bool Constant);
template <class RelTy>
bool constantEq(const InputSection *A, ArrayRef<RelTy> RelsA,
const InputSection *B, ArrayRef<RelTy> RelsB);
template <class RelTy>
bool variableEq(const InputSection *A, ArrayRef<RelTy> RelsA,
const InputSection *B, ArrayRef<RelTy> RelsB);
bool equalsConstant(const InputSection *A, const InputSection *B);
bool equalsVariable(const InputSection *A, const InputSection *B);
size_t findBoundary(size_t Begin, size_t End);
void forEachClassRange(size_t Begin, size_t End,
std::function<void(size_t, size_t)> Fn);
void forEachClass(std::function<void(size_t, size_t)> Fn);
std::vector<InputSection *> Sections;
// We repeat the main loop while `Repeat` is true.
std::atomic<bool> Repeat;
// The main loop counter.
int Cnt = 0;
// We have two locations for equivalence classes. On the first iteration
// of the main loop, Class[0] has a valid value, and Class[1] contains
// garbage. We read equivalence classes from slot 0 and write to slot 1.
// So, Class[0] represents the current class, and Class[1] represents
// the next class. On each iteration, we switch their roles and use them
// alternately.
//
// Why are we doing this? Recall that other threads may be working on
// other equivalence classes in parallel. They may read sections that we
// are updating. We cannot update equivalence classes in place because
// it breaks the invariance that all possibly-identical sections must be
// in the same equivalence class at any moment. In other words, the for
// loop to update equivalence classes is not atomic, and that is
// observable from other threads. By writing new classes to other
// places, we can keep the invariance.
//
// Below, `Current` has the index of the current class, and `Next` has
// the index of the next class. If threading is enabled, they are either
// (0, 1) or (1, 0).
//
// Note on single-thread: if that's the case, they are always (0, 0)
// because we can safely read the next class without worrying about race
// conditions. Using the same location makes this algorithm converge
// faster because it uses results of the same iteration earlier.
int Current = 0;
int Next = 0;
};
}
// Returns a hash value for S. Note that the information about
// relocation targets is not included in the hash value.
template <class ELFT> static uint32_t getHash(InputSection *S) {
return hash_combine(S->Flags, S->getSize(), S->NumRelocations, S->Data);
}
// Returns true if section S is subject of ICF.
static bool isEligible(InputSection *S) {
// Don't merge read only data sections unless
// --ignore-data-address-equality was passed.
if (!(S->Flags & SHF_EXECINSTR) && !Config->IgnoreDataAddressEquality)
return false;
// .init and .fini contains instructions that must be executed to
// initialize and finalize the process. They cannot and should not
// be merged.
return S->Live && (S->Flags & SHF_ALLOC) && !(S->Flags & SHF_WRITE) &&
S->Name != ".init" && S->Name != ".fini";
}
// Split an equivalence class into smaller classes.
template <class ELFT>
void ICF<ELFT>::segregate(size_t Begin, size_t End, bool Constant) {
// This loop rearranges sections in [Begin, End) so that all sections
// that are equal in terms of equals{Constant,Variable} are contiguous
// in [Begin, End).
//
// The algorithm is quadratic in the worst case, but that is not an
// issue in practice because the number of the distinct sections in
// each range is usually very small.
while (Begin < End) {
// Divide [Begin, End) into two. Let Mid be the start index of the
// second group.
auto Bound =
std::stable_partition(Sections.begin() + Begin + 1,
Sections.begin() + End, [&](InputSection *S) {
if (Constant)
return equalsConstant(Sections[Begin], S);
return equalsVariable(Sections[Begin], S);
});
size_t Mid = Bound - Sections.begin();
// Now we split [Begin, End) into [Begin, Mid) and [Mid, End) by
// updating the sections in [Begin, Mid). We use Mid as an equivalence
// class ID because every group ends with a unique index.
for (size_t I = Begin; I < Mid; ++I)
Sections[I]->Class[Next] = Mid;
// If we created a group, we need to iterate the main loop again.
if (Mid != End)
Repeat = true;
Begin = Mid;
}
}
// Compare two lists of relocations.
template <class ELFT>
template <class RelTy>
bool ICF<ELFT>::constantEq(const InputSection *SecA, ArrayRef<RelTy> RA,
const InputSection *SecB, ArrayRef<RelTy> RB) {
if (RA.size() != RB.size())
return false;
for (size_t I = 0; I < RA.size(); ++I) {
if (RA[I].r_offset != RB[I].r_offset ||
RA[I].getType(Config->IsMips64EL) != RB[I].getType(Config->IsMips64EL))
return false;
uint64_t AddA = getAddend<ELFT>(RA[I]);
uint64_t AddB = getAddend<ELFT>(RB[I]);
Symbol &SA = SecA->template getFile<ELFT>()->getRelocTargetSym(RA[I]);
Symbol &SB = SecB->template getFile<ELFT>()->getRelocTargetSym(RB[I]);
if (&SA == &SB) {
if (AddA == AddB)
continue;
return false;
}
auto *DA = dyn_cast<Defined>(&SA);
auto *DB = dyn_cast<Defined>(&SB);
if (!DA || !DB)
return false;
// Relocations referring to absolute symbols are constant-equal if their
// values are equal.
if (!DA->Section && !DB->Section && DA->Value + AddA == DB->Value + AddB)
continue;
if (!DA->Section || !DB->Section)
return false;
if (DA->Section->kind() != DB->Section->kind())
return false;
// Relocations referring to InputSections are constant-equal if their
// section offsets are equal.
if (isa<InputSection>(DA->Section)) {
if (DA->Value + AddA == DB->Value + AddB)
continue;
return false;
}
// Relocations referring to MergeInputSections are constant-equal if their
// offsets in the output section are equal.
auto *X = dyn_cast<MergeInputSection>(DA->Section);
if (!X)
return false;
auto *Y = cast<MergeInputSection>(DB->Section);
if (X->getParent() != Y->getParent())
return false;
uint64_t OffsetA =
SA.isSection() ? X->getOffset(AddA) : X->getOffset(DA->Value) + AddA;
uint64_t OffsetB =
SB.isSection() ? Y->getOffset(AddB) : Y->getOffset(DB->Value) + AddB;
if (OffsetA != OffsetB)
return false;
}
return true;
}
// Compare "non-moving" part of two InputSections, namely everything
// except relocation targets.
template <class ELFT>
bool ICF<ELFT>::equalsConstant(const InputSection *A, const InputSection *B) {
if (A->NumRelocations != B->NumRelocations || A->Flags != B->Flags ||
A->getSize() != B->getSize() || A->Data != B->Data)
return false;
if (A->AreRelocsRela)
return constantEq(A, A->template relas<ELFT>(), B,
B->template relas<ELFT>());
return constantEq(A, A->template rels<ELFT>(), B, B->template rels<ELFT>());
}
// Compare two lists of relocations. Returns true if all pairs of
// relocations point to the same section in terms of ICF.
template <class ELFT>
template <class RelTy>
bool ICF<ELFT>::variableEq(const InputSection *SecA, ArrayRef<RelTy> RA,
const InputSection *SecB, ArrayRef<RelTy> RB) {
assert(RA.size() == RB.size());
for (size_t I = 0; I < RA.size(); ++I) {
// The two sections must be identical.
Symbol &SA = SecA->template getFile<ELFT>()->getRelocTargetSym(RA[I]);
Symbol &SB = SecB->template getFile<ELFT>()->getRelocTargetSym(RB[I]);
if (&SA == &SB)
continue;
auto *DA = cast<Defined>(&SA);
auto *DB = cast<Defined>(&SB);
// We already dealt with absolute and non-InputSection symbols in
// constantEq, and for InputSections we have already checked everything
// except the equivalence class.
if (!DA->Section)
continue;
auto *X = dyn_cast<InputSection>(DA->Section);
if (!X)
continue;
auto *Y = cast<InputSection>(DB->Section);
// Ineligible sections are in the special equivalence class 0.
// They can never be the same in terms of the equivalence class.
if (X->Class[Current] == 0)
return false;
if (X->Class[Current] != Y->Class[Current])
return false;
};
return true;
}
// Compare "moving" part of two InputSections, namely relocation targets.
template <class ELFT>
bool ICF<ELFT>::equalsVariable(const InputSection *A, const InputSection *B) {
if (A->AreRelocsRela)
return variableEq(A, A->template relas<ELFT>(), B,
B->template relas<ELFT>());
return variableEq(A, A->template rels<ELFT>(), B, B->template rels<ELFT>());
}
template <class ELFT> size_t ICF<ELFT>::findBoundary(size_t Begin, size_t End) {
uint32_t Class = Sections[Begin]->Class[Current];
for (size_t I = Begin + 1; I < End; ++I)
if (Class != Sections[I]->Class[Current])
return I;
return End;
}
// Sections in the same equivalence class are contiguous in Sections
// vector. Therefore, Sections vector can be considered as contiguous
// groups of sections, grouped by the class.
//
// This function calls Fn on every group that starts within [Begin, End).
// Note that a group must start in that range but doesn't necessarily
// have to end before End.
template <class ELFT>
void ICF<ELFT>::forEachClassRange(size_t Begin, size_t End,
std::function<void(size_t, size_t)> Fn) {
if (Begin > 0)
Begin = findBoundary(Begin - 1, End);
while (Begin < End) {
size_t Mid = findBoundary(Begin, Sections.size());
Fn(Begin, Mid);
Begin = Mid;
}
}
// Call Fn on each equivalence class.
template <class ELFT>
void ICF<ELFT>::forEachClass(std::function<void(size_t, size_t)> Fn) {
// If threading is disabled or the number of sections are
// too small to use threading, call Fn sequentially.
if (!ThreadsEnabled || Sections.size() < 1024) {
forEachClassRange(0, Sections.size(), Fn);
++Cnt;
return;
}
Current = Cnt % 2;
Next = (Cnt + 1) % 2;
// Split sections into 256 shards and call Fn in parallel.
size_t NumShards = 256;
size_t Step = Sections.size() / NumShards;
parallelForEachN(0, NumShards, [&](size_t I) {
size_t End = (I == NumShards - 1) ? Sections.size() : (I + 1) * Step;
forEachClassRange(I * Step, End, Fn);
});
++Cnt;
}
static void Print(const Twine &Prefix, InputSection *S) {
if (!Config->PrintIcfSections)
return;
std::string File = S->File ? S->File->getName() : "<internal>";
message(Prefix + " section '" + S->Name + "' from file '" + File + "'");
}
// The main function of ICF.
template <class ELFT> void ICF<ELFT>::run() {
// Collect sections to merge.
for (InputSectionBase *Sec : InputSections)
if (auto *S = dyn_cast<InputSection>(Sec))
if (isEligible(S))
Sections.push_back(S);
// Initially, we use hash values to partition sections.
parallelForEach(Sections, [&](InputSection *S) {
// Set MSB to 1 to avoid collisions with non-hash IDs.
S->Class[0] = getHash<ELFT>(S) | (1 << 31);
});
// From now on, sections in Sections vector are ordered so that sections
// in the same equivalence class are consecutive in the vector.
std::stable_sort(Sections.begin(), Sections.end(),
[](InputSection *A, InputSection *B) {
return A->Class[0] < B->Class[0];
});
// Compare static contents and assign unique IDs for each static content.
forEachClass([&](size_t Begin, size_t End) { segregate(Begin, End, true); });
// Split groups by comparing relocations until convergence is obtained.
do {
Repeat = false;
forEachClass(
[&](size_t Begin, size_t End) { segregate(Begin, End, false); });
} while (Repeat);
log("ICF needed " + Twine(Cnt) + " iterations");
// Merge sections by the equivalence class.
forEachClassRange(0, Sections.size(), [&](size_t Begin, size_t End) {
if (End - Begin == 1)
return;
Print("selected", Sections[Begin]);
for (size_t I = Begin + 1; I < End; ++I) {
Print(" removing identical", Sections[I]);
Sections[Begin]->replace(Sections[I]);
}
});
// Mark ARM Exception Index table sections that refer to folded code
// sections as not live. These sections have an implict dependency
// via the link order dependency.
if (Config->EMachine == EM_ARM)
for (InputSectionBase *Sec : InputSections)
if (auto *S = dyn_cast<InputSection>(Sec))
if (S->Flags & SHF_LINK_ORDER)
S->Live = S->getLinkOrderDep()->Live;
}
// ICF entry point function.
template <class ELFT> void elf::doIcf() { ICF<ELFT>().run(); }
template void elf::doIcf<ELF32LE>();
template void elf::doIcf<ELF32BE>();
template void elf::doIcf<ELF64LE>();
template void elf::doIcf<ELF64BE>();
Fix coding style error.
git-svn-id: f6089bf0e6284f307027cef4f64114ee9ebb0424@325038 91177308-0d34-0410-b5e6-96231b3b80d8
//===- ICF.cpp ------------------------------------------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// ICF is short for Identical Code Folding. This is a size optimization to
// identify and merge two or more read-only sections (typically functions)
// that happened to have the same contents. It usually reduces output size
// by a few percent.
//
// In ICF, two sections are considered identical if they have the same
// section flags, section data, and relocations. Relocations are tricky,
// because two relocations are considered the same if they have the same
// relocation types, values, and if they point to the same sections *in
// terms of ICF*.
//
// Here is an example. If foo and bar defined below are compiled to the
// same machine instructions, ICF can and should merge the two, although
// their relocations point to each other.
//
// void foo() { bar(); }
// void bar() { foo(); }
//
// If you merge the two, their relocations point to the same section and
// thus you know they are mergeable, but how do you know they are
// mergeable in the first place? This is not an easy problem to solve.
//
// What we are doing in LLD is to partition sections into equivalence
// classes. Sections in the same equivalence class when the algorithm
// terminates are considered identical. Here are details:
//
// 1. First, we partition sections using their hash values as keys. Hash
// values contain section types, section contents and numbers of
// relocations. During this step, relocation targets are not taken into
// account. We just put sections that apparently differ into different
// equivalence classes.
//
// 2. Next, for each equivalence class, we visit sections to compare
// relocation targets. Relocation targets are considered equivalent if
// their targets are in the same equivalence class. Sections with
// different relocation targets are put into different equivalence
// clases.
//
// 3. If we split an equivalence class in step 2, two relocations
// previously target the same equivalence class may now target
// different equivalence classes. Therefore, we repeat step 2 until a
// convergence is obtained.
//
// 4. For each equivalence class C, pick an arbitrary section in C, and
// merge all the other sections in C with it.
//
// For small programs, this algorithm needs 3-5 iterations. For large
// programs such as Chromium, it takes more than 20 iterations.
//
// This algorithm was mentioned as an "optimistic algorithm" in [1],
// though gold implements a different algorithm than this.
//
// We parallelize each step so that multiple threads can work on different
// equivalence classes concurrently. That gave us a large performance
// boost when applying ICF on large programs. For example, MSVC link.exe
// or GNU gold takes 10-20 seconds to apply ICF on Chromium, whose output
// size is about 1.5 GB, but LLD can finish it in less than 2 seconds on a
// 2.8 GHz 40 core machine. Even without threading, LLD's ICF is still
// faster than MSVC or gold though.
//
// [1] Safe ICF: Pointer Safe and Unwinding aware Identical Code Folding
// in the Gold Linker
// http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36912.pdf
//
//===----------------------------------------------------------------------===//
#include "ICF.h"
#include "Config.h"
#include "SymbolTable.h"
#include "Symbols.h"
#include "lld/Common/Threads.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/Object/ELF.h"
#include <algorithm>
#include <atomic>
using namespace lld;
using namespace lld::elf;
using namespace llvm;
using namespace llvm::ELF;
using namespace llvm::object;
namespace {
template <class ELFT> class ICF {
public:
void run();
private:
void segregate(size_t Begin, size_t End, bool Constant);
template <class RelTy>
bool constantEq(const InputSection *A, ArrayRef<RelTy> RelsA,
const InputSection *B, ArrayRef<RelTy> RelsB);
template <class RelTy>
bool variableEq(const InputSection *A, ArrayRef<RelTy> RelsA,
const InputSection *B, ArrayRef<RelTy> RelsB);
bool equalsConstant(const InputSection *A, const InputSection *B);
bool equalsVariable(const InputSection *A, const InputSection *B);
size_t findBoundary(size_t Begin, size_t End);
void forEachClassRange(size_t Begin, size_t End,
std::function<void(size_t, size_t)> Fn);
void forEachClass(std::function<void(size_t, size_t)> Fn);
std::vector<InputSection *> Sections;
// We repeat the main loop while `Repeat` is true.
std::atomic<bool> Repeat;
// The main loop counter.
int Cnt = 0;
// We have two locations for equivalence classes. On the first iteration
// of the main loop, Class[0] has a valid value, and Class[1] contains
// garbage. We read equivalence classes from slot 0 and write to slot 1.
// So, Class[0] represents the current class, and Class[1] represents
// the next class. On each iteration, we switch their roles and use them
// alternately.
//
// Why are we doing this? Recall that other threads may be working on
// other equivalence classes in parallel. They may read sections that we
// are updating. We cannot update equivalence classes in place because
// it breaks the invariance that all possibly-identical sections must be
// in the same equivalence class at any moment. In other words, the for
// loop to update equivalence classes is not atomic, and that is
// observable from other threads. By writing new classes to other
// places, we can keep the invariance.
//
// Below, `Current` has the index of the current class, and `Next` has
// the index of the next class. If threading is enabled, they are either
// (0, 1) or (1, 0).
//
// Note on single-thread: if that's the case, they are always (0, 0)
// because we can safely read the next class without worrying about race
// conditions. Using the same location makes this algorithm converge
// faster because it uses results of the same iteration earlier.
int Current = 0;
int Next = 0;
};
}
// Returns a hash value for S. Note that the information about
// relocation targets is not included in the hash value.
template <class ELFT> static uint32_t getHash(InputSection *S) {
return hash_combine(S->Flags, S->getSize(), S->NumRelocations, S->Data);
}
// Returns true if section S is subject of ICF.
static bool isEligible(InputSection *S) {
// Don't merge read only data sections unless
// --ignore-data-address-equality was passed.
if (!(S->Flags & SHF_EXECINSTR) && !Config->IgnoreDataAddressEquality)
return false;
// .init and .fini contains instructions that must be executed to
// initialize and finalize the process. They cannot and should not
// be merged.
return S->Live && (S->Flags & SHF_ALLOC) && !(S->Flags & SHF_WRITE) &&
S->Name != ".init" && S->Name != ".fini";
}
// Split an equivalence class into smaller classes.
template <class ELFT>
void ICF<ELFT>::segregate(size_t Begin, size_t End, bool Constant) {
// This loop rearranges sections in [Begin, End) so that all sections
// that are equal in terms of equals{Constant,Variable} are contiguous
// in [Begin, End).
//
// The algorithm is quadratic in the worst case, but that is not an
// issue in practice because the number of the distinct sections in
// each range is usually very small.
while (Begin < End) {
// Divide [Begin, End) into two. Let Mid be the start index of the
// second group.
auto Bound =
std::stable_partition(Sections.begin() + Begin + 1,
Sections.begin() + End, [&](InputSection *S) {
if (Constant)
return equalsConstant(Sections[Begin], S);
return equalsVariable(Sections[Begin], S);
});
size_t Mid = Bound - Sections.begin();
// Now we split [Begin, End) into [Begin, Mid) and [Mid, End) by
// updating the sections in [Begin, Mid). We use Mid as an equivalence
// class ID because every group ends with a unique index.
for (size_t I = Begin; I < Mid; ++I)
Sections[I]->Class[Next] = Mid;
// If we created a group, we need to iterate the main loop again.
if (Mid != End)
Repeat = true;
Begin = Mid;
}
}
// Compare two lists of relocations.
template <class ELFT>
template <class RelTy>
bool ICF<ELFT>::constantEq(const InputSection *SecA, ArrayRef<RelTy> RA,
const InputSection *SecB, ArrayRef<RelTy> RB) {
if (RA.size() != RB.size())
return false;
for (size_t I = 0; I < RA.size(); ++I) {
if (RA[I].r_offset != RB[I].r_offset ||
RA[I].getType(Config->IsMips64EL) != RB[I].getType(Config->IsMips64EL))
return false;
uint64_t AddA = getAddend<ELFT>(RA[I]);
uint64_t AddB = getAddend<ELFT>(RB[I]);
Symbol &SA = SecA->template getFile<ELFT>()->getRelocTargetSym(RA[I]);
Symbol &SB = SecB->template getFile<ELFT>()->getRelocTargetSym(RB[I]);
if (&SA == &SB) {
if (AddA == AddB)
continue;
return false;
}
auto *DA = dyn_cast<Defined>(&SA);
auto *DB = dyn_cast<Defined>(&SB);
if (!DA || !DB)
return false;
// Relocations referring to absolute symbols are constant-equal if their
// values are equal.
if (!DA->Section && !DB->Section && DA->Value + AddA == DB->Value + AddB)
continue;
if (!DA->Section || !DB->Section)
return false;
if (DA->Section->kind() != DB->Section->kind())
return false;
// Relocations referring to InputSections are constant-equal if their
// section offsets are equal.
if (isa<InputSection>(DA->Section)) {
if (DA->Value + AddA == DB->Value + AddB)
continue;
return false;
}
// Relocations referring to MergeInputSections are constant-equal if their
// offsets in the output section are equal.
auto *X = dyn_cast<MergeInputSection>(DA->Section);
if (!X)
return false;
auto *Y = cast<MergeInputSection>(DB->Section);
if (X->getParent() != Y->getParent())
return false;
uint64_t OffsetA =
SA.isSection() ? X->getOffset(AddA) : X->getOffset(DA->Value) + AddA;
uint64_t OffsetB =
SB.isSection() ? Y->getOffset(AddB) : Y->getOffset(DB->Value) + AddB;
if (OffsetA != OffsetB)
return false;
}
return true;
}
// Compare "non-moving" part of two InputSections, namely everything
// except relocation targets.
template <class ELFT>
bool ICF<ELFT>::equalsConstant(const InputSection *A, const InputSection *B) {
if (A->NumRelocations != B->NumRelocations || A->Flags != B->Flags ||
A->getSize() != B->getSize() || A->Data != B->Data)
return false;
if (A->AreRelocsRela)
return constantEq(A, A->template relas<ELFT>(), B,
B->template relas<ELFT>());
return constantEq(A, A->template rels<ELFT>(), B, B->template rels<ELFT>());
}
// Compare two lists of relocations. Returns true if all pairs of
// relocations point to the same section in terms of ICF.
template <class ELFT>
template <class RelTy>
bool ICF<ELFT>::variableEq(const InputSection *SecA, ArrayRef<RelTy> RA,
const InputSection *SecB, ArrayRef<RelTy> RB) {
assert(RA.size() == RB.size());
for (size_t I = 0; I < RA.size(); ++I) {
// The two sections must be identical.
Symbol &SA = SecA->template getFile<ELFT>()->getRelocTargetSym(RA[I]);
Symbol &SB = SecB->template getFile<ELFT>()->getRelocTargetSym(RB[I]);
if (&SA == &SB)
continue;
auto *DA = cast<Defined>(&SA);
auto *DB = cast<Defined>(&SB);
// We already dealt with absolute and non-InputSection symbols in
// constantEq, and for InputSections we have already checked everything
// except the equivalence class.
if (!DA->Section)
continue;
auto *X = dyn_cast<InputSection>(DA->Section);
if (!X)
continue;
auto *Y = cast<InputSection>(DB->Section);
// Ineligible sections are in the special equivalence class 0.
// They can never be the same in terms of the equivalence class.
if (X->Class[Current] == 0)
return false;
if (X->Class[Current] != Y->Class[Current])
return false;
};
return true;
}
// Compare "moving" part of two InputSections, namely relocation targets.
template <class ELFT>
bool ICF<ELFT>::equalsVariable(const InputSection *A, const InputSection *B) {
if (A->AreRelocsRela)
return variableEq(A, A->template relas<ELFT>(), B,
B->template relas<ELFT>());
return variableEq(A, A->template rels<ELFT>(), B, B->template rels<ELFT>());
}
template <class ELFT> size_t ICF<ELFT>::findBoundary(size_t Begin, size_t End) {
uint32_t Class = Sections[Begin]->Class[Current];
for (size_t I = Begin + 1; I < End; ++I)
if (Class != Sections[I]->Class[Current])
return I;
return End;
}
// Sections in the same equivalence class are contiguous in Sections
// vector. Therefore, Sections vector can be considered as contiguous
// groups of sections, grouped by the class.
//
// This function calls Fn on every group that starts within [Begin, End).
// Note that a group must start in that range but doesn't necessarily
// have to end before End.
template <class ELFT>
void ICF<ELFT>::forEachClassRange(size_t Begin, size_t End,
std::function<void(size_t, size_t)> Fn) {
if (Begin > 0)
Begin = findBoundary(Begin - 1, End);
while (Begin < End) {
size_t Mid = findBoundary(Begin, Sections.size());
Fn(Begin, Mid);
Begin = Mid;
}
}
// Call Fn on each equivalence class.
template <class ELFT>
void ICF<ELFT>::forEachClass(std::function<void(size_t, size_t)> Fn) {
// If threading is disabled or the number of sections are
// too small to use threading, call Fn sequentially.
if (!ThreadsEnabled || Sections.size() < 1024) {
forEachClassRange(0, Sections.size(), Fn);
++Cnt;
return;
}
Current = Cnt % 2;
Next = (Cnt + 1) % 2;
// Split sections into 256 shards and call Fn in parallel.
size_t NumShards = 256;
size_t Step = Sections.size() / NumShards;
parallelForEachN(0, NumShards, [&](size_t I) {
size_t End = (I == NumShards - 1) ? Sections.size() : (I + 1) * Step;
forEachClassRange(I * Step, End, Fn);
});
++Cnt;
}
static void print(const Twine &Prefix, InputSection *S) {
if (!Config->PrintIcfSections)
return;
std::string File = S->File ? S->File->getName() : "<internal>";
message(Prefix + " section '" + S->Name + "' from file '" + File + "'");
}
// The main function of ICF.
template <class ELFT> void ICF<ELFT>::run() {
// Collect sections to merge.
for (InputSectionBase *Sec : InputSections)
if (auto *S = dyn_cast<InputSection>(Sec))
if (isEligible(S))
Sections.push_back(S);
// Initially, we use hash values to partition sections.
parallelForEach(Sections, [&](InputSection *S) {
// Set MSB to 1 to avoid collisions with non-hash IDs.
S->Class[0] = getHash<ELFT>(S) | (1 << 31);
});
// From now on, sections in Sections vector are ordered so that sections
// in the same equivalence class are consecutive in the vector.
std::stable_sort(Sections.begin(), Sections.end(),
[](InputSection *A, InputSection *B) {
return A->Class[0] < B->Class[0];
});
// Compare static contents and assign unique IDs for each static content.
forEachClass([&](size_t Begin, size_t End) { segregate(Begin, End, true); });
// Split groups by comparing relocations until convergence is obtained.
do {
Repeat = false;
forEachClass(
[&](size_t Begin, size_t End) { segregate(Begin, End, false); });
} while (Repeat);
log("ICF needed " + Twine(Cnt) + " iterations");
// Merge sections by the equivalence class.
forEachClassRange(0, Sections.size(), [&](size_t Begin, size_t End) {
if (End - Begin == 1)
return;
print("selected", Sections[Begin]);
for (size_t I = Begin + 1; I < End; ++I) {
print(" removing identical", Sections[I]);
Sections[Begin]->replace(Sections[I]);
}
});
// Mark ARM Exception Index table sections that refer to folded code
// sections as not live. These sections have an implict dependency
// via the link order dependency.
if (Config->EMachine == EM_ARM)
for (InputSectionBase *Sec : InputSections)
if (auto *S = dyn_cast<InputSection>(Sec))
if (S->Flags & SHF_LINK_ORDER)
S->Live = S->getLinkOrderDep()->Live;
}
// ICF entry point function.
template <class ELFT> void elf::doIcf() { ICF<ELFT>().run(); }
template void elf::doIcf<ELF32LE>();
template void elf::doIcf<ELF32BE>();
template void elf::doIcf<ELF64LE>();
template void elf::doIcf<ELF64BE>();
|
// *****************************************************************************
//
// Copyright (c) 2014, Southwest Research Institute® (SwRI®)
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of Southwest Research Institute® (SwRI®) nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// *****************************************************************************
#include <stdint.h>
#include <swri_geometry_util/intersection.h>
#define HAVE_INT64_T_64 # Prevents conflict with OpenCV typedef of int64
#include <geos/geom/CoordinateArraySequence.h>
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/Polygon.h>
#undef HAVE_INT64_T_64
namespace swri_geometry_util
{
bool LineIntersection(
const cv::Vec2d& p1,
const cv::Vec2d& p2,
const cv::Vec2d& p3,
const cv::Vec2d& p4,
cv::Vec2d& c)
{
double d = (p1[0] - p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * (p3[0] - p4[0]);
if (d == 0)
{
return false;
}
double n_a = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[0] - p4[0]) - (p1[0] - p2[0]) * (p3[0] * p4[1] - p3[1] * p4[0]);
double n_b = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * (p3[0] * p4[1] - p3[1] * p4[0]);
c[0] = n_a / d;
c[1] = n_b / d;
return true;
}
bool LineSegmentIntersection(
const cv::Vec2d& p1,
const cv::Vec2d& p2,
const cv::Vec2d& p3,
const cv::Vec2d& p4,
cv::Vec2d& c)
{
// See: "Intersection of two lines in three-space"
// by Ronald Goldman from Graphics Gems
// Handle case of singe points.
if (p1 == p2)
{
if (PointOnLineSegment(p1, p3, p4))
{
c = p1;
return true;
}
return false;
}
else if (p3 == p4)
{
if (PointOnLineSegment(p3, p1, p2))
{
c = p3;
return true;
}
return false;
}
cv::Point2d p(p1);
cv::Point2d r(p2 - p1);
cv::Point2d q(p3);
cv::Point2d s(p4 - p3);
cv::Point2d qp(q - p);
double rs = r.cross(s);
if (std::fabs(rs) > std::numeric_limits<float>::epsilon())
{
// Explicitly divide components since cv::Point doesn't support division
// in indigo.
double t = qp.cross(cv::Point2d(s.x / rs, s.y / rs));
double u = (qp * -1).cross(cv::Point2d(r.x / -rs, r.y / -rs));
if (u >= 0 && t >= 0 && u <= 1.0 && t <= 1.0)
{
// The lines intersect within the line segments.
c = p + t * r;
return true;
}
else
{
// The lines intersect, but outside the line segments.
return false;
}
}
else if (std::fabs(qp.cross(r)) > std::numeric_limits<float>::epsilon())
{
// The lines are parellel and non-intersecting.
return false;
}
else
{
// The lines are parellel and coincident.
double rlen = r.dot(r);
cv::Point2d unit_r(r.x / rlen, r.y / rlen);
double t0 = qp.dot(unit_r);
double t1 = t0 + s.dot(unit_r);
if (t0 > t1)
{
std::swap(t0, t1);
}
if (t0 <= 1.0 && t1 >= 0.0)
{
// The line segments overlap.
double t = std::max(0.0, t0);
c = p + t * r;
return true;
}
// The line segments don't overlap.
return false;
}
}
bool PointOnLineSegment(
const cv::Vec2d& p1,
const cv::Vec2d& p2,
const cv::Vec2d& p3)
{
// Check if the points are collinear.
if (((p2[0] - p1[0]) * (p3[1] - p1[0])) - ((p3[0] - p1[0]) * (p2[1] - p1[1])) > std::numeric_limits<float>::epsilon())
{
return false;
}
if (p2[0] != p3[0])
{
return (p1[0] <= p3[0] && p2[0] <= p1[0]) || (p1[0] <= p2[0] && p3[0] <= p1[0]);
}
else
{
return (p1[1] <= p3[1] && p2[1] <= p1[1]) || (p1[1] <= p2[1] && p3[1] <= p1[1]);
}
}
bool PolygonsIntersect(
const std::vector<cv::Vec2d>& a,
const std::vector<cv::Vec2d>& b)
{
// Create GEOS polygon from vertices in vector a.
geos::geom::CoordinateSequence* a_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < a.size(); i++)
{
a_coords->add(geos::geom::Coordinate(a[i][0], a[i][1]));
}
a_coords->add(a_coords->front());
geos::geom::LinearRing* a_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(a_coords);
geos::geom::Polygon* a_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(a_ring, 0);
a_polygon->normalize();
// Create GEOS polygon from vertices in vector b.
geos::geom::CoordinateSequence* b_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < b.size(); i++)
{
b_coords->add(geos::geom::Coordinate(b[i][0], b[i][1]));
}
b_coords->add(b_coords->front());
geos::geom::LinearRing* b_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(b_coords);
geos::geom::Polygon* b_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(b_ring, 0);
b_polygon->normalize();
bool intersects = a_polygon->intersects(b_polygon);
// Free polygon objects.
delete a_polygon;
delete b_polygon;
return intersects;
}
double PolygonIntersectionArea(
const std::vector<cv::Vec2d>& a,
const std::vector<cv::Vec2d>& b)
{
if (a.size() < 3 || b.size() < 3)
{
return 0;
}
double area = 0;
// Create GEOS polygon from vertices in vector a.
geos::geom::CoordinateSequence* a_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < a.size(); i++)
{
a_coords->add(geos::geom::Coordinate(a[i][0], a[i][1]));
}
a_coords->add(a_coords->front());
geos::geom::LinearRing* a_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(a_coords);
geos::geom::Polygon* a_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(a_ring, 0);
a_polygon->normalize();
// Create GEOS polygon from vertices in vector b.
geos::geom::CoordinateSequence* b_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < b.size(); i++)
{
b_coords->add(geos::geom::Coordinate(b[i][0], b[i][1]));
}
b_coords->add(b_coords->front());
geos::geom::LinearRing* b_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(b_coords);
geos::geom::Polygon* b_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(b_ring, 0);
b_polygon->normalize();
if (a_polygon->intersects(b_polygon))
{
area = a_polygon->intersection(b_polygon)->getArea();
}
// Free polygon objects.
delete a_polygon;
delete b_polygon;
return area;
}
}
Catch exceptions when computing area
// *****************************************************************************
//
// Copyright (c) 2014, Southwest Research Institute® (SwRI®)
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of Southwest Research Institute® (SwRI®) nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// *****************************************************************************
#include <stdint.h>
#include <swri_geometry_util/intersection.h>
#define HAVE_INT64_T_64 # Prevents conflict with OpenCV typedef of int64
#include <geos/geom/CoordinateArraySequence.h>
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/Polygon.h>
#include <geos/util/TopologyException.h>
#undef HAVE_INT64_T_64
namespace swri_geometry_util
{
bool LineIntersection(
const cv::Vec2d& p1,
const cv::Vec2d& p2,
const cv::Vec2d& p3,
const cv::Vec2d& p4,
cv::Vec2d& c)
{
double d = (p1[0] - p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * (p3[0] - p4[0]);
if (d == 0)
{
return false;
}
double n_a = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[0] - p4[0]) - (p1[0] - p2[0]) * (p3[0] * p4[1] - p3[1] * p4[0]);
double n_b = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * (p3[0] * p4[1] - p3[1] * p4[0]);
c[0] = n_a / d;
c[1] = n_b / d;
return true;
}
bool LineSegmentIntersection(
const cv::Vec2d& p1,
const cv::Vec2d& p2,
const cv::Vec2d& p3,
const cv::Vec2d& p4,
cv::Vec2d& c)
{
// See: "Intersection of two lines in three-space"
// by Ronald Goldman from Graphics Gems
// Handle case of singe points.
if (p1 == p2)
{
if (PointOnLineSegment(p1, p3, p4))
{
c = p1;
return true;
}
return false;
}
else if (p3 == p4)
{
if (PointOnLineSegment(p3, p1, p2))
{
c = p3;
return true;
}
return false;
}
cv::Point2d p(p1);
cv::Point2d r(p2 - p1);
cv::Point2d q(p3);
cv::Point2d s(p4 - p3);
cv::Point2d qp(q - p);
double rs = r.cross(s);
if (std::fabs(rs) > std::numeric_limits<float>::epsilon())
{
// Explicitly divide components since cv::Point doesn't support division
// in indigo.
double t = qp.cross(cv::Point2d(s.x / rs, s.y / rs));
double u = (qp * -1).cross(cv::Point2d(r.x / -rs, r.y / -rs));
if (u >= 0 && t >= 0 && u <= 1.0 && t <= 1.0)
{
// The lines intersect within the line segments.
c = p + t * r;
return true;
}
else
{
// The lines intersect, but outside the line segments.
return false;
}
}
else if (std::fabs(qp.cross(r)) > std::numeric_limits<float>::epsilon())
{
// The lines are parellel and non-intersecting.
return false;
}
else
{
// The lines are parellel and coincident.
double rlen = r.dot(r);
cv::Point2d unit_r(r.x / rlen, r.y / rlen);
double t0 = qp.dot(unit_r);
double t1 = t0 + s.dot(unit_r);
if (t0 > t1)
{
std::swap(t0, t1);
}
if (t0 <= 1.0 && t1 >= 0.0)
{
// The line segments overlap.
double t = std::max(0.0, t0);
c = p + t * r;
return true;
}
// The line segments don't overlap.
return false;
}
}
bool PointOnLineSegment(
const cv::Vec2d& p1,
const cv::Vec2d& p2,
const cv::Vec2d& p3)
{
// Check if the points are collinear.
if (((p2[0] - p1[0]) * (p3[1] - p1[0])) - ((p3[0] - p1[0]) * (p2[1] - p1[1])) > std::numeric_limits<float>::epsilon())
{
return false;
}
if (p2[0] != p3[0])
{
return (p1[0] <= p3[0] && p2[0] <= p1[0]) || (p1[0] <= p2[0] && p3[0] <= p1[0]);
}
else
{
return (p1[1] <= p3[1] && p2[1] <= p1[1]) || (p1[1] <= p2[1] && p3[1] <= p1[1]);
}
}
bool PolygonsIntersect(
const std::vector<cv::Vec2d>& a,
const std::vector<cv::Vec2d>& b)
{
// Create GEOS polygon from vertices in vector a.
geos::geom::CoordinateSequence* a_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < a.size(); i++)
{
a_coords->add(geos::geom::Coordinate(a[i][0], a[i][1]));
}
a_coords->add(a_coords->front());
geos::geom::LinearRing* a_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(a_coords);
geos::geom::Polygon* a_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(a_ring, 0);
a_polygon->normalize();
// Create GEOS polygon from vertices in vector b.
geos::geom::CoordinateSequence* b_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < b.size(); i++)
{
b_coords->add(geos::geom::Coordinate(b[i][0], b[i][1]));
}
b_coords->add(b_coords->front());
geos::geom::LinearRing* b_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(b_coords);
geos::geom::Polygon* b_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(b_ring, 0);
b_polygon->normalize();
bool intersects = a_polygon->intersects(b_polygon);
// Free polygon objects.
delete a_polygon;
delete b_polygon;
return intersects;
}
double PolygonIntersectionArea(
const std::vector<cv::Vec2d>& a,
const std::vector<cv::Vec2d>& b)
{
if (a.size() < 3 || b.size() < 3)
{
return 0;
}
double area = 0;
// Create GEOS polygon from vertices in vector a.
geos::geom::CoordinateSequence* a_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < a.size(); i++)
{
a_coords->add(geos::geom::Coordinate(a[i][0], a[i][1]));
}
a_coords->add(a_coords->front());
geos::geom::LinearRing* a_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(a_coords);
geos::geom::Polygon* a_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(a_ring, 0);
a_polygon->normalize();
// Create GEOS polygon from vertices in vector b.
geos::geom::CoordinateSequence* b_coords = new geos::geom::CoordinateArraySequence();
for (size_t i = 0; i < b.size(); i++)
{
b_coords->add(geos::geom::Coordinate(b[i][0], b[i][1]));
}
b_coords->add(b_coords->front());
geos::geom::LinearRing* b_ring = geos::geom::GeometryFactory::getDefaultInstance()->createLinearRing(b_coords);
geos::geom::Polygon* b_polygon = geos::geom::GeometryFactory::getDefaultInstance()->createPolygon(b_ring, 0);
b_polygon->normalize();
try
{
if (a_polygon->intersects(b_polygon))
{
area = a_polygon->intersection(b_polygon)->getArea();
}
}
catch (const geos::util::TopologyException& e)
{
// TODO Fix this
}
// Free polygon objects.
delete a_polygon;
delete b_polygon;
return area;
}
}
|
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2010, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*
*/
#include <list>
#include <pcl/visualization/common/io.h>
#include <pcl/visualization/interactor_style.h>
#include <vtkPolyData.h>
#include <vtkMapper.h>
#include <vtkPolyDataMapper.h>
#include <vtkPointData.h>
#include <vtkCellArray.h>
#include <vtkAppendPolyData.h>
#include <vtkTextProperty.h>
#include <vtkAbstractPicker.h>
#include <vtkAbstractPropPicker.h>
#include <vtkPlanes.h>
#include <vtkPointPicker.h>
#include <vtkMatrix4x4.h>
#include <vtk-5.6/vtkInteractorObserver.h>
#include <vtk-5.6/vtkCamera.h>
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::Initialize ()
{
modifier_ = pcl::visualization::INTERACTOR_KB_MOD_ALT;
// Set windows size (width, height) to unknown (-1)
win_height_ = win_width_ = -1;
win_pos_x_ = win_pos_y_ = 0;
max_win_height_ = max_win_width_ = -1;
// Grid is disabled by default
grid_enabled_ = false;
grid_actor_ = vtkSmartPointer<vtkLegendScaleActor>::New ();
// LUT is disabled by default
lut_enabled_ = false;
lut_actor_ = vtkSmartPointer<vtkScalarBarActor>::New ();
lut_actor_->SetTitle ("");
lut_actor_->SetOrientationToHorizontal ();
lut_actor_->SetPosition (0.05, 0.01);
lut_actor_->SetWidth (0.9);
lut_actor_->SetHeight (0.1);
lut_actor_->SetNumberOfLabels (lut_actor_->GetNumberOfLabels () * 2);
vtkSmartPointer<vtkTextProperty> prop = lut_actor_->GetLabelTextProperty ();
prop->SetFontSize (10);
lut_actor_->SetLabelTextProperty (prop);
lut_actor_->SetTitleTextProperty (prop);
// Create the image filter and PNG writer objects
wif_ = vtkSmartPointer<vtkWindowToImageFilter>::New ();
snapshot_writer_ = vtkSmartPointer<vtkPNGWriter>::New ();
snapshot_writer_->SetInputConnection (wif_->GetOutputPort ());
init_ = true;
stereo_anaglyph_mask_default_ = true;
// Add our own mouse callback before any user callback. Used for accurate point picking.
mouse_callback_ = vtkSmartPointer<pcl::visualization::PointPickingCallback>::New ();
AddObserver (vtkCommand::LeftButtonPressEvent, mouse_callback_);
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::saveScreenshot (const std::string &file)
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
wif_->SetInput (Interactor->GetRenderWindow ());
wif_->Modified (); // Update the WindowToImageFilter
snapshot_writer_->Modified ();
snapshot_writer_->SetFileName (file.c_str ());
snapshot_writer_->Write ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::zoomIn ()
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
// Zoom in
StartDolly ();
double factor = 10.0 * 0.2 * .5;
Dolly (pow (1.1, factor));
EndDolly ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::zoomOut ()
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
// Zoom out
StartDolly ();
double factor = 10.0 * -0.2 * .5;
Dolly (pow (1.1, factor));
EndDolly ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnChar ()
{
// Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
if (Interactor->GetKeyCode () >= '0' && Interactor->GetKeyCode () <= '9')
return;
std::string key (Interactor->GetKeySym ());
if (key.find ("XF86ZoomIn") != std::string::npos)
zoomIn ();
else if (key.find ("XF86ZoomOut") != std::string::npos)
zoomOut ();
bool keymod = false;
switch (modifier_)
{
case INTERACTOR_KB_MOD_ALT:
{
keymod = Interactor->GetAltKey ();
break;
}
case INTERACTOR_KB_MOD_CTRL:
{
keymod = Interactor->GetControlKey ();
break;
}
case INTERACTOR_KB_MOD_SHIFT:
{
keymod = Interactor->GetShiftKey ();
break;
}
}
switch (Interactor->GetKeyCode ())
{
// All of the options below simply exit
case 'h': case 'H':
case 'l': case 'L':
case 'p': case 'P':
case 'j': case 'J':
case 'c': case 'C':
case 43: // KEY_PLUS
case 45: // KEY_MINUS
case 'f': case 'F':
case 'g': case 'G':
case 'o': case 'O':
case 'u': case 'U':
case 'q': case 'Q':
{
break;
}
// S and R have a special !ALT case
case 'r': case 'R':
case 's': case 'S':
{
if (!keymod)
Superclass::OnChar ();
break;
}
default:
{
Superclass::OnChar ();
break;
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::PCLVisualizerInteractorStyle::registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> callback)
{
return (mouse_signal_.connect (callback));
}
//////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::PCLVisualizerInteractorStyle::registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> callback)
{
return (keyboard_signal_.connect (callback));
}
//////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::PCLVisualizerInteractorStyle::registerPointPickingCallback (boost::function<void (const pcl::visualization::PointPickingEvent&)> callback)
{
return (point_picking_signal_.connect (callback));
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnKeyDown ()
{
if (!init_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
if (!rens_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing.\n");
return;
}
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
if (wif_->GetInput () == NULL)
{
wif_->SetInput (Interactor->GetRenderWindow ());
wif_->Modified ();
snapshot_writer_->Modified ();
}
// Save the initial windows width/height
if (win_height_ == -1 || win_width_ == -1)
{
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
win_height_ = win_size[0];
win_width_ = win_size[1];
}
// Get the status of special keys (Cltr+Alt+Shift)
bool shift = Interactor->GetShiftKey ();
bool ctrl = Interactor->GetControlKey ();
bool alt = Interactor->GetAltKey ();
bool keymod = false;
switch (modifier_)
{
case INTERACTOR_KB_MOD_ALT:
{
keymod = alt;
break;
}
case INTERACTOR_KB_MOD_CTRL:
{
keymod = ctrl;
break;
}
case INTERACTOR_KB_MOD_SHIFT:
{
keymod = shift;
break;
}
}
// ---[ Check the rest of the key codes
// Switch between point color/geometry handlers
if (Interactor->GetKeySym () && Interactor->GetKeySym ()[0] >= '0' && Interactor->GetKeySym ()[0] <= '9')
{
CloudActorMap::iterator it;
int index = Interactor->GetKeySym ()[0] - '0' - 1;
if (index == -1) index = 9;
// Add 10 more for CTRL+0..9 keys
if (ctrl)
index += 10;
// Geometry ?
if (keymod)
{
for (it = actors_->begin (); it != actors_->end (); ++it)
{
CloudActor *act = &(*it).second;
if (index >= static_cast<int> (act->geometry_handlers.size ()))
continue;
// Save the geometry handler index for later usage
act->geometry_handler_index_ = index;
// Create the new geometry
PointCloudGeometryHandler<sensor_msgs::PointCloud2>::ConstPtr geometry_handler = act->geometry_handlers[index];
// Use the handler to obtain the geometry
vtkSmartPointer<vtkPoints> points;
geometry_handler->getGeometry (points);
// Set the vertices
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New ();
for (vtkIdType i = 0; i < (int)points->GetNumberOfPoints (); ++i)
vertices->InsertNextCell ((vtkIdType)1, &i);
// Create the data
vtkSmartPointer<vtkPolyData> data = vtkSmartPointer<vtkPolyData>::New ();
data->SetPoints (points);
data->SetVerts (vertices);
// Modify the mapper
vtkPolyDataMapper* mapper = static_cast<vtkPolyDataMapper*>(act->actor->GetMapper ());
mapper->SetInput (data);
// Modify the actor
act->actor->SetMapper (mapper);
act->actor->Modified ();
}
}
else
{
for (it = actors_->begin (); it != actors_->end (); ++it)
{
CloudActor *act = &(*it).second;
// Check for out of bounds
if (index >= (int)act->color_handlers.size ())
continue;
// Save the color handler index for later usage
act->color_handler_index_ = index;
// Get the new color
PointCloudColorHandler<sensor_msgs::PointCloud2>::ConstPtr color_handler = act->color_handlers[index];
vtkSmartPointer<vtkDataArray> scalars;
color_handler->getColor (scalars);
double minmax[2];
scalars->GetRange (minmax);
// Update the data
vtkPolyData *data = static_cast<vtkPolyData*>(act->actor->GetMapper ()->GetInput ());
data->GetPointData ()->SetScalars (scalars);
data->Update ();
// Modify the mapper
vtkPolyDataMapper* mapper = static_cast<vtkPolyDataMapper*>(act->actor->GetMapper ());
mapper->SetScalarRange (minmax);
mapper->SetScalarModeToUsePointData ();
mapper->SetInput (data);
// Modify the actor
act->actor->SetMapper (mapper);
act->actor->Modified ();
}
}
Interactor->Render ();
return;
}
std::string key (Interactor->GetKeySym ());
if (key.find ("XF86ZoomIn") != std::string::npos)
zoomIn ();
else if (key.find ("XF86ZoomOut") != std::string::npos)
zoomOut ();
switch (Interactor->GetKeyCode ())
{
case 'h': case 'H':
{
pcl::console::print_info ("| Help:\n"
"-------\n"
" p, P : switch to a point-based representation\n"
" w, W : switch to a wireframe-based representation (where available)\n"
" s, S : switch to a surface-based representation (where available)\n"
"\n"
" j, J : take a .PNG snapshot of the current window view\n"
" c, C : display current camera/window parameters\n"
" f, F : fly to point mode\n"
"\n"
" e, E : exit the interactor\n"
" q, Q : stop and call VTK's TerminateApp\n"
"\n"
" +/- : increment/decrement overall point size\n"
" +/- [+ ALT] : zoom in/out \n"
"\n"
" g, G : display scale grid (on/off)\n"
" u, U : display lookup table (on/off)\n"
"\n"
" r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n"
"\n"
" ALT + s, S : turn stereo mode on/off\n"
" ALT + f, F : switch between maximized window mode and original size\n"
"\n"
" l, L : list all available geometric and color handlers for the current actor map\n"
" ALT + 0..9 [+ CTRL] : switch between different geometric handlers (where available)\n"
" 0..9 [+ CTRL] : switch between different color handlers (where available)\n"
"\n"
" SHIFT + left click : select a point\n"
);
break;
}
// Get the list of available handlers
case 'l': case 'L':
{
// Iterate over the entire actors list and extract the geomotry/color handlers list
for (CloudActorMap::iterator it = actors_->begin (); it != actors_->end (); ++it)
{
std::list<std::string> geometry_handlers_list, color_handlers_list;
CloudActor *act = &(*it).second;
for (size_t i = 0; i < act->geometry_handlers.size (); ++i)
geometry_handlers_list.push_back (act->geometry_handlers[i]->getFieldName ());
for (size_t i = 0; i < act->color_handlers.size (); ++i)
color_handlers_list.push_back (act->color_handlers[i]->getFieldName ());
if (!geometry_handlers_list.empty ())
{
int i = 0;
pcl::console::print_info ("List of available geometry handlers for actor "); pcl::console::print_value ("%s: ", (*it).first.c_str ());
for (std::list<std::string>::iterator git = geometry_handlers_list.begin (); git != geometry_handlers_list.end (); ++git)
pcl::console::print_value ("%s(%d) ", (*git).c_str (), ++i);
pcl::console::print_info ("\n");
}
if (!color_handlers_list.empty ())
{
int i = 0;
pcl::console::print_info ("List of available color handlers for actor "); pcl::console::print_value ("%s: ", (*it).first.c_str ());
for (std::list<std::string>::iterator cit = color_handlers_list.begin (); cit != color_handlers_list.end (); ++cit)
pcl::console::print_value ("%s(%d) ", (*cit).c_str (), ++i);
pcl::console::print_info ("\n");
}
}
break;
}
// Switch representation to points
case 'p': case 'P':
{
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
{
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
{
vtkSmartPointer<vtkActor> apart = (vtkActor*)path->GetLastNode ()->GetViewProp ();
apart->GetProperty ()->SetRepresentationToPoints ();
}
}
break;
}
// Save a PNG snapshot with the current screen
case 'j': case 'J':
{
char cam_fn[80], snapshot_fn[80];
unsigned t = time (0);
sprintf (snapshot_fn, "screenshot-%d.png" , t);
saveScreenshot (snapshot_fn);
sprintf (cam_fn, "screenshot-%d.cam", t);
ofstream ofs_cam;
ofs_cam.open (cam_fn);
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
double clip[2], focal[3], pos[3], view[3];
cam->GetClippingRange (clip);
cam->GetFocalPoint (focal);
cam->GetPosition (pos);
cam->GetViewUp (view);
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
ofs_cam << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
<< endl;
ofs_cam.close ();
pcl::console::print_info ("Screenshot (%s) and camera information (%s) successfully captured.\n", snapshot_fn, cam_fn);
break;
}
// display current camera settings/parameters
case 'c': case 'C':
{
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
double clip[2], focal[3], pos[3], view[3];
cam->GetClippingRange (clip);
cam->GetFocalPoint (focal);
cam->GetPosition (pos);
cam->GetViewUp (view);
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
std::cerr << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
<< endl;
break;
}
case '=':
{
zoomIn();
break;
}
case 43: // KEY_PLUS
{
if(alt)
zoomIn ();
else
{
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
{
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
{
vtkSmartPointer<vtkActor> apart = (vtkActor*)path->GetLastNode ()->GetViewProp ();
int psize = apart->GetProperty ()->GetPointSize ();
if (psize < 63)
apart->GetProperty ()->SetPointSize (psize + 1);
}
}
}
break;
}
case 45: // KEY_MINUS
{
if(alt)
zoomOut ();
else
{
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
{
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
{
vtkSmartPointer<vtkActor> apart = (vtkActor*)path->GetLastNode ()->GetViewProp ();
int psize = apart->GetProperty ()->GetPointSize ();
if (psize > 1)
apart->GetProperty ()->SetPointSize (psize - 1);
}
}
}
break;
}
// Switch between maximize and original window size
case 'f': case 'F':
{
if (keymod)
{
// Get screen size
int *temp = Interactor->GetRenderWindow ()->GetScreenSize ();
int scr_size[2]; scr_size[0] = temp[0]; scr_size[1] = temp[1];
// Get window size
temp = Interactor->GetRenderWindow ()->GetSize ();
int win_size[2]; win_size[0] = temp[0]; win_size[1] = temp[1];
// Is window size = max?
if (win_size[0] == max_win_height_ && win_size[1] == max_win_width_)
{
// Set the previously saved 'current' window size
Interactor->GetRenderWindow ()->SetSize (win_height_, win_width_);
// Set the previously saved window position
Interactor->GetRenderWindow ()->SetPosition (win_pos_x_, win_pos_y_);
Interactor->GetRenderWindow ()->Render ();
Interactor->Render ();
}
// Set to max
else
{
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
// Save the current window position
win_pos_x_ = win_pos[0];
win_pos_y_ = win_pos[1];
// Save the current window size
win_height_ = win_size[0];
win_width_ = win_size[1];
// Set the maximum window size
Interactor->GetRenderWindow ()->SetSize (scr_size[0], scr_size[1]);
Interactor->GetRenderWindow ()->Render ();
Interactor->Render ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
// Save the maximum window size
max_win_height_ = win_size[0];
max_win_width_ = win_size[1];
}
}
else
{
AnimState = VTKIS_ANIM_ON;
vtkAssemblyPath *path = NULL;
Interactor->GetPicker ()->Pick (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1], 0.0, CurrentRenderer);
vtkAbstractPropPicker *picker;
if ((picker = vtkAbstractPropPicker::SafeDownCast (Interactor->GetPicker ())))
path = picker->GetPath ();
if (path != NULL)
Interactor->FlyTo (CurrentRenderer, picker->GetPickPosition ());
AnimState = VTKIS_ANIM_OFF;
}
break;
}
// 's'/'S' w/out ALT
case 's': case 'S':
{
if (keymod)
{
int stereo_render = Interactor->GetRenderWindow ()->GetStereoRender ();
if (!stereo_render)
{
if (stereo_anaglyph_mask_default_)
{
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (4, 3);
stereo_anaglyph_mask_default_ = false;
}
else
{
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (2, 5);
stereo_anaglyph_mask_default_ = true;
}
}
Interactor->GetRenderWindow ()->SetStereoRender (!stereo_render);
Interactor->GetRenderWindow ()->Render ();
Interactor->Render ();
}
else
Superclass::OnKeyDown ();
break;
}
// Display a grid/scale over the screen
case 'g': case 'G':
{
if (!grid_enabled_)
{
grid_actor_->TopAxisVisibilityOn ();
CurrentRenderer->AddViewProp (grid_actor_);
grid_enabled_ = true;
}
else
{
CurrentRenderer->RemoveViewProp (grid_actor_);
grid_enabled_ = false;
}
break;
}
case 'o': case 'O':
{
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
int flag = cam->GetParallelProjection ();
cam->SetParallelProjection (!flag);
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->Render ();
break;
}
// Display a LUT actor on screen
case 'u': case 'U':
{
CloudActorMap::iterator it;
for (it = actors_->begin (); it != actors_->end (); ++it)
{
CloudActor *act = &(*it).second;
vtkScalarsToColors* lut = act->actor->GetMapper ()->GetLookupTable ();
lut_actor_->SetLookupTable (lut);
lut_actor_->Modified ();
}
if (!lut_enabled_)
{
CurrentRenderer->AddActor (lut_actor_);
lut_actor_->SetVisibility (true);
lut_enabled_ = true;
}
else
{
CurrentRenderer->RemoveActor (lut_actor_);
lut_enabled_ = false;
}
CurrentRenderer->Render ();
break;
}
// Overwrite the camera reset
case 'r': case 'R':
{
if (!keymod)
{
Superclass::OnKeyDown ();
break;
}
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
static CloudActorMap::iterator it = actors_->begin ();
if (actors_->size () > 0)
{
if (it == actors_->end ())
it = actors_->begin ();
const CloudActor& actor = it->second;
cam->SetPosition (actor.viewpoint_transformation_->GetElement (0, 3),
actor.viewpoint_transformation_->GetElement (1, 3),
actor.viewpoint_transformation_->GetElement (2, 3));
cam->SetFocalPoint (actor.viewpoint_transformation_->GetElement (0, 3) - actor.viewpoint_transformation_->GetElement (0, 2),
actor.viewpoint_transformation_->GetElement (1, 3) - actor.viewpoint_transformation_->GetElement (1, 2),
actor.viewpoint_transformation_->GetElement (2, 3) - actor.viewpoint_transformation_->GetElement (2, 2));
cam->SetViewUp (actor.viewpoint_transformation_->GetElement (0, 1),
actor.viewpoint_transformation_->GetElement (1, 1),
actor.viewpoint_transformation_->GetElement (2, 1));
++it;
}
else
{
cam->SetPosition (0, 0, 0);
cam->SetFocalPoint (0, 0, 1);
cam->SetViewUp (0, -1, 0);
}
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->ResetCameraClippingRange ();
CurrentRenderer->Render ();
break;
}
case 'q': case 'Q':
{
Interactor->ExitCallback ();
return;
}
default:
{
Superclass::OnKeyDown ();
break;
}
}
KeyboardEvent event (true, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
keyboard_signal_ (event);
rens_->Render ();
Interactor->Render ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnKeyUp ()
{
KeyboardEvent event (false, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
keyboard_signal_ (event);
Superclass::OnKeyUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMouseMove ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnMouseMove ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnLeftButtonDown ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
if (Interactor->GetRepeatCount () == 0)
{
MouseEvent event (MouseEvent::MouseButtonPress, MouseEvent::LeftButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
else
{
MouseEvent event (MouseEvent::MouseDblClick, MouseEvent::LeftButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
Superclass::OnLeftButtonDown ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnLeftButtonUp ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnLeftButtonUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMiddleButtonDown ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
if (Interactor->GetRepeatCount () == 0)
{
MouseEvent event (MouseEvent::MouseButtonPress, MouseEvent::MiddleButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
else
{
MouseEvent event (MouseEvent::MouseDblClick, MouseEvent::MiddleButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
Superclass::OnMiddleButtonDown ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMiddleButtonUp ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnMiddleButtonUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnRightButtonDown ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
if (Interactor->GetRepeatCount () == 0)
{
MouseEvent event (MouseEvent::MouseButtonPress, MouseEvent::RightButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
else
{
MouseEvent event (MouseEvent::MouseDblClick, MouseEvent::RightButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
Superclass::OnRightButtonDown ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnRightButtonUp ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::RightButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnRightButtonUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMouseWheelForward ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseScrollUp, MouseEvent::VScroll, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
if (Interactor->GetRepeatCount ())
mouse_signal_ (event);
if (Interactor->GetAltKey ())
{
// zoom
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
double opening_angle = cam->GetViewAngle ();
if (opening_angle > 15.0)
opening_angle -= 1.0;
cam->SetViewAngle (opening_angle);
cam->Modified ();
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->ResetCameraClippingRange ();
CurrentRenderer->Modified ();
CurrentRenderer->Render ();
rens_->Render ();
Interactor->Render ();
}
else
Superclass::OnMouseWheelForward ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMouseWheelBackward ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseScrollDown, MouseEvent::VScroll, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
if (Interactor->GetRepeatCount ())
mouse_signal_ (event);
if (Interactor->GetAltKey ())
{
// zoom
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
double opening_angle = cam->GetViewAngle ();
if (opening_angle < 170.0)
opening_angle += 1.0;
cam->SetViewAngle (opening_angle);
cam->Modified ();
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->ResetCameraClippingRange ();
CurrentRenderer->Modified ();
CurrentRenderer->Render ();
rens_->Render ();
Interactor->Render ();
}
else
Superclass::OnMouseWheelBackward ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnTimer ()
{
if (!init_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
if (!rens_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing.\n");
return;
}
rens_->Render ();
Interactor->Render ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLHistogramVisualizerInteractorStyle::Initialize ()
{
init_ = true;
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLHistogramVisualizerInteractorStyle::OnKeyDown ()
{
if (!init_)
{
pcl::console::print_error ("[PCLHistogramVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
//fprintf (stderr, "Key sym: %s\n", Interactor->GetKeySym ());
// ---[ Check the rest of the key codes
switch (Interactor->GetKeyCode ())
{
case 'q': case 'Q':
{
Interactor->ExitCallback ();
return;
}
// Switch representation to wireframe
default:
{
Superclass::OnKeyDown ();
}
}
Interactor->Render ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLHistogramVisualizerInteractorStyle::OnTimer ()
{
if (!init_)
{
pcl::console::print_error ("[PCLHistogramVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
for (RenWinInteractMap::iterator am_it = wins_.begin (); am_it != wins_.end (); ++am_it)
(*am_it).second.ren_->Render ();
}
namespace pcl
{
namespace visualization
{
// Standard VTK macro for *New ()
vtkStandardNewMacro (PCLVisualizerInteractorStyle);
vtkStandardNewMacro (PCLHistogramVisualizerInteractorStyle);
}
}
removed vtk5.6
git-svn-id: e7ea667a1d39a4453c4efcc4ba7bca3d620c3f19@5063 a9d63959-f2ad-4865-b262-bf0e56cfafb6
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2010, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*
*/
#include <list>
#include <pcl/visualization/common/io.h>
#include <pcl/visualization/interactor_style.h>
#include <vtkPolyData.h>
#include <vtkMapper.h>
#include <vtkPolyDataMapper.h>
#include <vtkPointData.h>
#include <vtkCellArray.h>
#include <vtkAppendPolyData.h>
#include <vtkTextProperty.h>
#include <vtkAbstractPicker.h>
#include <vtkAbstractPropPicker.h>
#include <vtkPlanes.h>
#include <vtkPointPicker.h>
#include <vtkMatrix4x4.h>
#include <vtkInteractorObserver.h>
#include <vtkCamera.h>
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::Initialize ()
{
modifier_ = pcl::visualization::INTERACTOR_KB_MOD_ALT;
// Set windows size (width, height) to unknown (-1)
win_height_ = win_width_ = -1;
win_pos_x_ = win_pos_y_ = 0;
max_win_height_ = max_win_width_ = -1;
// Grid is disabled by default
grid_enabled_ = false;
grid_actor_ = vtkSmartPointer<vtkLegendScaleActor>::New ();
// LUT is disabled by default
lut_enabled_ = false;
lut_actor_ = vtkSmartPointer<vtkScalarBarActor>::New ();
lut_actor_->SetTitle ("");
lut_actor_->SetOrientationToHorizontal ();
lut_actor_->SetPosition (0.05, 0.01);
lut_actor_->SetWidth (0.9);
lut_actor_->SetHeight (0.1);
lut_actor_->SetNumberOfLabels (lut_actor_->GetNumberOfLabels () * 2);
vtkSmartPointer<vtkTextProperty> prop = lut_actor_->GetLabelTextProperty ();
prop->SetFontSize (10);
lut_actor_->SetLabelTextProperty (prop);
lut_actor_->SetTitleTextProperty (prop);
// Create the image filter and PNG writer objects
wif_ = vtkSmartPointer<vtkWindowToImageFilter>::New ();
snapshot_writer_ = vtkSmartPointer<vtkPNGWriter>::New ();
snapshot_writer_->SetInputConnection (wif_->GetOutputPort ());
init_ = true;
stereo_anaglyph_mask_default_ = true;
// Add our own mouse callback before any user callback. Used for accurate point picking.
mouse_callback_ = vtkSmartPointer<pcl::visualization::PointPickingCallback>::New ();
AddObserver (vtkCommand::LeftButtonPressEvent, mouse_callback_);
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::saveScreenshot (const std::string &file)
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
wif_->SetInput (Interactor->GetRenderWindow ());
wif_->Modified (); // Update the WindowToImageFilter
snapshot_writer_->Modified ();
snapshot_writer_->SetFileName (file.c_str ());
snapshot_writer_->Write ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::zoomIn ()
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
// Zoom in
StartDolly ();
double factor = 10.0 * 0.2 * .5;
Dolly (pow (1.1, factor));
EndDolly ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::zoomOut ()
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
// Zoom out
StartDolly ();
double factor = 10.0 * -0.2 * .5;
Dolly (pow (1.1, factor));
EndDolly ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnChar ()
{
// Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
if (Interactor->GetKeyCode () >= '0' && Interactor->GetKeyCode () <= '9')
return;
std::string key (Interactor->GetKeySym ());
if (key.find ("XF86ZoomIn") != std::string::npos)
zoomIn ();
else if (key.find ("XF86ZoomOut") != std::string::npos)
zoomOut ();
bool keymod = false;
switch (modifier_)
{
case INTERACTOR_KB_MOD_ALT:
{
keymod = Interactor->GetAltKey ();
break;
}
case INTERACTOR_KB_MOD_CTRL:
{
keymod = Interactor->GetControlKey ();
break;
}
case INTERACTOR_KB_MOD_SHIFT:
{
keymod = Interactor->GetShiftKey ();
break;
}
}
switch (Interactor->GetKeyCode ())
{
// All of the options below simply exit
case 'h': case 'H':
case 'l': case 'L':
case 'p': case 'P':
case 'j': case 'J':
case 'c': case 'C':
case 43: // KEY_PLUS
case 45: // KEY_MINUS
case 'f': case 'F':
case 'g': case 'G':
case 'o': case 'O':
case 'u': case 'U':
case 'q': case 'Q':
{
break;
}
// S and R have a special !ALT case
case 'r': case 'R':
case 's': case 'S':
{
if (!keymod)
Superclass::OnChar ();
break;
}
default:
{
Superclass::OnChar ();
break;
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::PCLVisualizerInteractorStyle::registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> callback)
{
return (mouse_signal_.connect (callback));
}
//////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::PCLVisualizerInteractorStyle::registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> callback)
{
return (keyboard_signal_.connect (callback));
}
//////////////////////////////////////////////////////////////////////////////////////////////
boost::signals2::connection
pcl::visualization::PCLVisualizerInteractorStyle::registerPointPickingCallback (boost::function<void (const pcl::visualization::PointPickingEvent&)> callback)
{
return (point_picking_signal_.connect (callback));
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnKeyDown ()
{
if (!init_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
if (!rens_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing.\n");
return;
}
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
if (wif_->GetInput () == NULL)
{
wif_->SetInput (Interactor->GetRenderWindow ());
wif_->Modified ();
snapshot_writer_->Modified ();
}
// Save the initial windows width/height
if (win_height_ == -1 || win_width_ == -1)
{
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
win_height_ = win_size[0];
win_width_ = win_size[1];
}
// Get the status of special keys (Cltr+Alt+Shift)
bool shift = Interactor->GetShiftKey ();
bool ctrl = Interactor->GetControlKey ();
bool alt = Interactor->GetAltKey ();
bool keymod = false;
switch (modifier_)
{
case INTERACTOR_KB_MOD_ALT:
{
keymod = alt;
break;
}
case INTERACTOR_KB_MOD_CTRL:
{
keymod = ctrl;
break;
}
case INTERACTOR_KB_MOD_SHIFT:
{
keymod = shift;
break;
}
}
// ---[ Check the rest of the key codes
// Switch between point color/geometry handlers
if (Interactor->GetKeySym () && Interactor->GetKeySym ()[0] >= '0' && Interactor->GetKeySym ()[0] <= '9')
{
CloudActorMap::iterator it;
int index = Interactor->GetKeySym ()[0] - '0' - 1;
if (index == -1) index = 9;
// Add 10 more for CTRL+0..9 keys
if (ctrl)
index += 10;
// Geometry ?
if (keymod)
{
for (it = actors_->begin (); it != actors_->end (); ++it)
{
CloudActor *act = &(*it).second;
if (index >= static_cast<int> (act->geometry_handlers.size ()))
continue;
// Save the geometry handler index for later usage
act->geometry_handler_index_ = index;
// Create the new geometry
PointCloudGeometryHandler<sensor_msgs::PointCloud2>::ConstPtr geometry_handler = act->geometry_handlers[index];
// Use the handler to obtain the geometry
vtkSmartPointer<vtkPoints> points;
geometry_handler->getGeometry (points);
// Set the vertices
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New ();
for (vtkIdType i = 0; i < (int)points->GetNumberOfPoints (); ++i)
vertices->InsertNextCell ((vtkIdType)1, &i);
// Create the data
vtkSmartPointer<vtkPolyData> data = vtkSmartPointer<vtkPolyData>::New ();
data->SetPoints (points);
data->SetVerts (vertices);
// Modify the mapper
vtkPolyDataMapper* mapper = static_cast<vtkPolyDataMapper*>(act->actor->GetMapper ());
mapper->SetInput (data);
// Modify the actor
act->actor->SetMapper (mapper);
act->actor->Modified ();
}
}
else
{
for (it = actors_->begin (); it != actors_->end (); ++it)
{
CloudActor *act = &(*it).second;
// Check for out of bounds
if (index >= (int)act->color_handlers.size ())
continue;
// Save the color handler index for later usage
act->color_handler_index_ = index;
// Get the new color
PointCloudColorHandler<sensor_msgs::PointCloud2>::ConstPtr color_handler = act->color_handlers[index];
vtkSmartPointer<vtkDataArray> scalars;
color_handler->getColor (scalars);
double minmax[2];
scalars->GetRange (minmax);
// Update the data
vtkPolyData *data = static_cast<vtkPolyData*>(act->actor->GetMapper ()->GetInput ());
data->GetPointData ()->SetScalars (scalars);
data->Update ();
// Modify the mapper
vtkPolyDataMapper* mapper = static_cast<vtkPolyDataMapper*>(act->actor->GetMapper ());
mapper->SetScalarRange (minmax);
mapper->SetScalarModeToUsePointData ();
mapper->SetInput (data);
// Modify the actor
act->actor->SetMapper (mapper);
act->actor->Modified ();
}
}
Interactor->Render ();
return;
}
std::string key (Interactor->GetKeySym ());
if (key.find ("XF86ZoomIn") != std::string::npos)
zoomIn ();
else if (key.find ("XF86ZoomOut") != std::string::npos)
zoomOut ();
switch (Interactor->GetKeyCode ())
{
case 'h': case 'H':
{
pcl::console::print_info ("| Help:\n"
"-------\n"
" p, P : switch to a point-based representation\n"
" w, W : switch to a wireframe-based representation (where available)\n"
" s, S : switch to a surface-based representation (where available)\n"
"\n"
" j, J : take a .PNG snapshot of the current window view\n"
" c, C : display current camera/window parameters\n"
" f, F : fly to point mode\n"
"\n"
" e, E : exit the interactor\n"
" q, Q : stop and call VTK's TerminateApp\n"
"\n"
" +/- : increment/decrement overall point size\n"
" +/- [+ ALT] : zoom in/out \n"
"\n"
" g, G : display scale grid (on/off)\n"
" u, U : display lookup table (on/off)\n"
"\n"
" r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n"
"\n"
" ALT + s, S : turn stereo mode on/off\n"
" ALT + f, F : switch between maximized window mode and original size\n"
"\n"
" l, L : list all available geometric and color handlers for the current actor map\n"
" ALT + 0..9 [+ CTRL] : switch between different geometric handlers (where available)\n"
" 0..9 [+ CTRL] : switch between different color handlers (where available)\n"
"\n"
" SHIFT + left click : select a point\n"
);
break;
}
// Get the list of available handlers
case 'l': case 'L':
{
// Iterate over the entire actors list and extract the geomotry/color handlers list
for (CloudActorMap::iterator it = actors_->begin (); it != actors_->end (); ++it)
{
std::list<std::string> geometry_handlers_list, color_handlers_list;
CloudActor *act = &(*it).second;
for (size_t i = 0; i < act->geometry_handlers.size (); ++i)
geometry_handlers_list.push_back (act->geometry_handlers[i]->getFieldName ());
for (size_t i = 0; i < act->color_handlers.size (); ++i)
color_handlers_list.push_back (act->color_handlers[i]->getFieldName ());
if (!geometry_handlers_list.empty ())
{
int i = 0;
pcl::console::print_info ("List of available geometry handlers for actor "); pcl::console::print_value ("%s: ", (*it).first.c_str ());
for (std::list<std::string>::iterator git = geometry_handlers_list.begin (); git != geometry_handlers_list.end (); ++git)
pcl::console::print_value ("%s(%d) ", (*git).c_str (), ++i);
pcl::console::print_info ("\n");
}
if (!color_handlers_list.empty ())
{
int i = 0;
pcl::console::print_info ("List of available color handlers for actor "); pcl::console::print_value ("%s: ", (*it).first.c_str ());
for (std::list<std::string>::iterator cit = color_handlers_list.begin (); cit != color_handlers_list.end (); ++cit)
pcl::console::print_value ("%s(%d) ", (*cit).c_str (), ++i);
pcl::console::print_info ("\n");
}
}
break;
}
// Switch representation to points
case 'p': case 'P':
{
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
{
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
{
vtkSmartPointer<vtkActor> apart = (vtkActor*)path->GetLastNode ()->GetViewProp ();
apart->GetProperty ()->SetRepresentationToPoints ();
}
}
break;
}
// Save a PNG snapshot with the current screen
case 'j': case 'J':
{
char cam_fn[80], snapshot_fn[80];
unsigned t = time (0);
sprintf (snapshot_fn, "screenshot-%d.png" , t);
saveScreenshot (snapshot_fn);
sprintf (cam_fn, "screenshot-%d.cam", t);
ofstream ofs_cam;
ofs_cam.open (cam_fn);
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
double clip[2], focal[3], pos[3], view[3];
cam->GetClippingRange (clip);
cam->GetFocalPoint (focal);
cam->GetPosition (pos);
cam->GetViewUp (view);
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
ofs_cam << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
<< endl;
ofs_cam.close ();
pcl::console::print_info ("Screenshot (%s) and camera information (%s) successfully captured.\n", snapshot_fn, cam_fn);
break;
}
// display current camera settings/parameters
case 'c': case 'C':
{
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
double clip[2], focal[3], pos[3], view[3];
cam->GetClippingRange (clip);
cam->GetFocalPoint (focal);
cam->GetPosition (pos);
cam->GetViewUp (view);
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
std::cerr << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
<< endl;
break;
}
case '=':
{
zoomIn();
break;
}
case 43: // KEY_PLUS
{
if(alt)
zoomIn ();
else
{
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
{
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
{
vtkSmartPointer<vtkActor> apart = (vtkActor*)path->GetLastNode ()->GetViewProp ();
int psize = apart->GetProperty ()->GetPointSize ();
if (psize < 63)
apart->GetProperty ()->SetPointSize (psize + 1);
}
}
}
break;
}
case 45: // KEY_MINUS
{
if(alt)
zoomOut ();
else
{
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
{
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
{
vtkSmartPointer<vtkActor> apart = (vtkActor*)path->GetLastNode ()->GetViewProp ();
int psize = apart->GetProperty ()->GetPointSize ();
if (psize > 1)
apart->GetProperty ()->SetPointSize (psize - 1);
}
}
}
break;
}
// Switch between maximize and original window size
case 'f': case 'F':
{
if (keymod)
{
// Get screen size
int *temp = Interactor->GetRenderWindow ()->GetScreenSize ();
int scr_size[2]; scr_size[0] = temp[0]; scr_size[1] = temp[1];
// Get window size
temp = Interactor->GetRenderWindow ()->GetSize ();
int win_size[2]; win_size[0] = temp[0]; win_size[1] = temp[1];
// Is window size = max?
if (win_size[0] == max_win_height_ && win_size[1] == max_win_width_)
{
// Set the previously saved 'current' window size
Interactor->GetRenderWindow ()->SetSize (win_height_, win_width_);
// Set the previously saved window position
Interactor->GetRenderWindow ()->SetPosition (win_pos_x_, win_pos_y_);
Interactor->GetRenderWindow ()->Render ();
Interactor->Render ();
}
// Set to max
else
{
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
// Save the current window position
win_pos_x_ = win_pos[0];
win_pos_y_ = win_pos[1];
// Save the current window size
win_height_ = win_size[0];
win_width_ = win_size[1];
// Set the maximum window size
Interactor->GetRenderWindow ()->SetSize (scr_size[0], scr_size[1]);
Interactor->GetRenderWindow ()->Render ();
Interactor->Render ();
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
// Save the maximum window size
max_win_height_ = win_size[0];
max_win_width_ = win_size[1];
}
}
else
{
AnimState = VTKIS_ANIM_ON;
vtkAssemblyPath *path = NULL;
Interactor->GetPicker ()->Pick (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1], 0.0, CurrentRenderer);
vtkAbstractPropPicker *picker;
if ((picker = vtkAbstractPropPicker::SafeDownCast (Interactor->GetPicker ())))
path = picker->GetPath ();
if (path != NULL)
Interactor->FlyTo (CurrentRenderer, picker->GetPickPosition ());
AnimState = VTKIS_ANIM_OFF;
}
break;
}
// 's'/'S' w/out ALT
case 's': case 'S':
{
if (keymod)
{
int stereo_render = Interactor->GetRenderWindow ()->GetStereoRender ();
if (!stereo_render)
{
if (stereo_anaglyph_mask_default_)
{
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (4, 3);
stereo_anaglyph_mask_default_ = false;
}
else
{
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (2, 5);
stereo_anaglyph_mask_default_ = true;
}
}
Interactor->GetRenderWindow ()->SetStereoRender (!stereo_render);
Interactor->GetRenderWindow ()->Render ();
Interactor->Render ();
}
else
Superclass::OnKeyDown ();
break;
}
// Display a grid/scale over the screen
case 'g': case 'G':
{
if (!grid_enabled_)
{
grid_actor_->TopAxisVisibilityOn ();
CurrentRenderer->AddViewProp (grid_actor_);
grid_enabled_ = true;
}
else
{
CurrentRenderer->RemoveViewProp (grid_actor_);
grid_enabled_ = false;
}
break;
}
case 'o': case 'O':
{
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
int flag = cam->GetParallelProjection ();
cam->SetParallelProjection (!flag);
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->Render ();
break;
}
// Display a LUT actor on screen
case 'u': case 'U':
{
CloudActorMap::iterator it;
for (it = actors_->begin (); it != actors_->end (); ++it)
{
CloudActor *act = &(*it).second;
vtkScalarsToColors* lut = act->actor->GetMapper ()->GetLookupTable ();
lut_actor_->SetLookupTable (lut);
lut_actor_->Modified ();
}
if (!lut_enabled_)
{
CurrentRenderer->AddActor (lut_actor_);
lut_actor_->SetVisibility (true);
lut_enabled_ = true;
}
else
{
CurrentRenderer->RemoveActor (lut_actor_);
lut_enabled_ = false;
}
CurrentRenderer->Render ();
break;
}
// Overwrite the camera reset
case 'r': case 'R':
{
if (!keymod)
{
Superclass::OnKeyDown ();
break;
}
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
static CloudActorMap::iterator it = actors_->begin ();
if (actors_->size () > 0)
{
if (it == actors_->end ())
it = actors_->begin ();
const CloudActor& actor = it->second;
cam->SetPosition (actor.viewpoint_transformation_->GetElement (0, 3),
actor.viewpoint_transformation_->GetElement (1, 3),
actor.viewpoint_transformation_->GetElement (2, 3));
cam->SetFocalPoint (actor.viewpoint_transformation_->GetElement (0, 3) - actor.viewpoint_transformation_->GetElement (0, 2),
actor.viewpoint_transformation_->GetElement (1, 3) - actor.viewpoint_transformation_->GetElement (1, 2),
actor.viewpoint_transformation_->GetElement (2, 3) - actor.viewpoint_transformation_->GetElement (2, 2));
cam->SetViewUp (actor.viewpoint_transformation_->GetElement (0, 1),
actor.viewpoint_transformation_->GetElement (1, 1),
actor.viewpoint_transformation_->GetElement (2, 1));
++it;
}
else
{
cam->SetPosition (0, 0, 0);
cam->SetFocalPoint (0, 0, 1);
cam->SetViewUp (0, -1, 0);
}
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->ResetCameraClippingRange ();
CurrentRenderer->Render ();
break;
}
case 'q': case 'Q':
{
Interactor->ExitCallback ();
return;
}
default:
{
Superclass::OnKeyDown ();
break;
}
}
KeyboardEvent event (true, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
keyboard_signal_ (event);
rens_->Render ();
Interactor->Render ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnKeyUp ()
{
KeyboardEvent event (false, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
keyboard_signal_ (event);
Superclass::OnKeyUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMouseMove ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnMouseMove ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnLeftButtonDown ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
if (Interactor->GetRepeatCount () == 0)
{
MouseEvent event (MouseEvent::MouseButtonPress, MouseEvent::LeftButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
else
{
MouseEvent event (MouseEvent::MouseDblClick, MouseEvent::LeftButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
Superclass::OnLeftButtonDown ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnLeftButtonUp ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnLeftButtonUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMiddleButtonDown ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
if (Interactor->GetRepeatCount () == 0)
{
MouseEvent event (MouseEvent::MouseButtonPress, MouseEvent::MiddleButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
else
{
MouseEvent event (MouseEvent::MouseDblClick, MouseEvent::MiddleButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
Superclass::OnMiddleButtonDown ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMiddleButtonUp ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnMiddleButtonUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnRightButtonDown ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
if (Interactor->GetRepeatCount () == 0)
{
MouseEvent event (MouseEvent::MouseButtonPress, MouseEvent::RightButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
else
{
MouseEvent event (MouseEvent::MouseDblClick, MouseEvent::RightButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
}
Superclass::OnRightButtonDown ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnRightButtonUp ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::RightButton, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
Superclass::OnRightButtonUp ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMouseWheelForward ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseScrollUp, MouseEvent::VScroll, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
if (Interactor->GetRepeatCount ())
mouse_signal_ (event);
if (Interactor->GetAltKey ())
{
// zoom
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
double opening_angle = cam->GetViewAngle ();
if (opening_angle > 15.0)
opening_angle -= 1.0;
cam->SetViewAngle (opening_angle);
cam->Modified ();
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->ResetCameraClippingRange ();
CurrentRenderer->Modified ();
CurrentRenderer->Render ();
rens_->Render ();
Interactor->Render ();
}
else
Superclass::OnMouseWheelForward ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnMouseWheelBackward ()
{
int x = this->Interactor->GetEventPosition()[0];
int y = this->Interactor->GetEventPosition()[1];
MouseEvent event (MouseEvent::MouseScrollDown, MouseEvent::VScroll, x, y, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
mouse_signal_ (event);
if (Interactor->GetRepeatCount ())
mouse_signal_ (event);
if (Interactor->GetAltKey ())
{
// zoom
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
double opening_angle = cam->GetViewAngle ();
if (opening_angle < 170.0)
opening_angle += 1.0;
cam->SetViewAngle (opening_angle);
cam->Modified ();
CurrentRenderer->SetActiveCamera (cam);
CurrentRenderer->ResetCameraClippingRange ();
CurrentRenderer->Modified ();
CurrentRenderer->Render ();
rens_->Render ();
Interactor->Render ();
}
else
Superclass::OnMouseWheelBackward ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLVisualizerInteractorStyle::OnTimer ()
{
if (!init_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
if (!rens_)
{
pcl::console::print_error ("[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing.\n");
return;
}
rens_->Render ();
Interactor->Render ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLHistogramVisualizerInteractorStyle::Initialize ()
{
init_ = true;
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLHistogramVisualizerInteractorStyle::OnKeyDown ()
{
if (!init_)
{
pcl::console::print_error ("[PCLHistogramVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
//fprintf (stderr, "Key sym: %s\n", Interactor->GetKeySym ());
// ---[ Check the rest of the key codes
switch (Interactor->GetKeyCode ())
{
case 'q': case 'Q':
{
Interactor->ExitCallback ();
return;
}
// Switch representation to wireframe
default:
{
Superclass::OnKeyDown ();
}
}
Interactor->Render ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
void
pcl::visualization::PCLHistogramVisualizerInteractorStyle::OnTimer ()
{
if (!init_)
{
pcl::console::print_error ("[PCLHistogramVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n");
return;
}
for (RenWinInteractMap::iterator am_it = wins_.begin (); am_it != wins_.end (); ++am_it)
(*am_it).second.ren_->Render ();
}
namespace pcl
{
namespace visualization
{
// Standard VTK macro for *New ()
vtkStandardNewMacro (PCLVisualizerInteractorStyle);
vtkStandardNewMacro (PCLHistogramVisualizerInteractorStyle);
}
}
|
#include <QDateTime>
#include <QDebug>
#include "lua_task.h"
#include "task.h"
#include "objectmanager.h"
#include "connection.h"
#include "lua_moo.h"
#include "lua_object.h"
#include "lua_verb.h"
#include "lua_connection.h"
#include "verb.h"
#include "mooexception.h"
#include "connectionmanager.h"
#include "taskentry.h"
#include "inputsinkprogram.h"
#include <iostream>
const luaL_Reg lua_task::mLuaStatic[] =
{
{ "task", lua_task::luaTask },
{ "kill", lua_task::luaKill },
{ 0, 0 }
};
const luaL_Reg lua_task::mLuaGet[] =
{
{ "object", lua_task::luaObject },
{ "verb", lua_task::luaVerb },
{ "args", lua_task::luaArgs },
{ "argstr", lua_task::luaArgStr },
{ "caller", lua_task::luaCaller },
{ "here", lua_task::luaHere },
{ "me", lua_task::luaMe },
{ "player", lua_task::luaPlayer },
{ "dobj", lua_task::luaDirectObject },
{ "dobjstr", lua_task::luaDirectObjectString },
{ "iobj", lua_task::luaIndirectObject },
{ "iobjstr", lua_task::luaIndirectObjectString },
{ "prepstr", lua_task::luaPreposition },
{ "programmer", lua_task::luaGetProgrammer },
{ 0, 0 }
};
const luaL_Reg lua_task::mLuaSet[] =
{
{ "programmer", lua_task::luaSetProgrammer },
{ 0, 0 }
};
void lua_task::initialise()
{
lua_moo::addFunctions( mLuaStatic );
lua_moo::addGet( mLuaGet );
lua_moo::addSet( mLuaSet );
}
void lua_task::luaRegisterState( lua_State *L )
{
Q_UNUSED( L )
}
int lua_task::luaObject( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.object() );
return( 1 );
}
int lua_task::luaVerb( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.verb().toLatin1() );
return( 1 );
}
int lua_task::luaArgs( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
const QStringList &W = T.args();
lua_newtable( L );
for( int i = 0 ; i < W.size() ; i++ )
{
lua_pushinteger( L, i + 1 );
lua_pushstring( L, W.at( i ).toLatin1() );
lua_settable( L, -3 );
}
return( 1 );
}
int lua_task::luaArgStr(lua_State *L)
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.argstr().toLatin1() );
return( 1 );
}
int lua_task::luaCaller( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.caller() );
return( 1 );
}
int lua_task::luaPlayer( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.player() );
return( 1 );
}
int lua_task::luaHere( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
Object *O = ObjectManager::o( T.player() );
lua_object::lua_pushobjectid( L, O == 0 ? OBJECT_NONE : O->location() );
return( 1 );
}
int lua_task::luaMe( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.player() );
return( 1 );
}
int lua_task::luaTask( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
luaL_checkinteger( L, 1 );
luaL_checkstring( L, 2 );
lua_task *lt = lua_task::luaGetTask( L );
TaskEntry E( QString( lua_tostring( L, 2 ) ), lt->connectionid(), T.programmer() );
E.setTimeStamp( E.timestamp() + ( lua_tonumber( L, 1 ) * 1000.0 ) );
ObjectManager::instance()->queueTask( E );
lua_pushinteger( L, E.id() );
return( 1 );
}
int lua_task::luaKill(lua_State *L)
{
luaL_checkinteger( L, 1 );
TaskId tid = lua_tointeger( L, 1 );
lua_pushboolean( L, ObjectManager::instance()->killTask( tid ) );
return( 1 );
}
int lua_task::luaDirectObject( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.directObjectId() );
return( 1 );
}
int lua_task::luaDirectObjectString(lua_State *L)
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.directObjectName().toUtf8() );
return( 1 );
}
int lua_task::luaIndirectObject( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.indirectObjectId() );
return( 1 );
}
int lua_task::luaIndirectObjectString(lua_State *L)
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.indirectObjectName().toUtf8() );
return( 1 );
}
int lua_task::luaPreposition( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.preposition().toUtf8() );
return( 1 );
}
int lua_task::luaGetProgrammer( lua_State *L )
{
const lua_task *LT = lua_task::luaGetTask( L );
lua_object::lua_pushobjectid( L, LT->programmer() );
return( 1 );
}
int lua_task::luaSetProgrammer( lua_State *L )
{
lua_task *LT = lua_task::luaGetTask( L );
ObjectId WID = lua_object::argId( L, -1 );
Object *PRG = ObjectManager::o( LT->programmer() );
if( PRG->id() == WID || PRG->wizard() )
{
LT->setProgrammer( WID );
}
else
{
luaL_error( L, "bad permissions" );
}
return( 0 );
}
lua_task::lua_task( ConnectionId pConnectionId, const Task &pTask )
: mL( 0 ), mConnectionId( pConnectionId ), mMemUse( 0 )
{
mTasks.push_front( pTask );
}
lua_task::~lua_task( void )
{
if( mL != 0 )
{
lua_close( mL );
mL = 0;
}
}
lua_State *lua_task::L()
{
if( mL == 0 )
{
if( ( mL = lua_newstate( lua_task::luaAlloc, this ) ) == 0 )
{
return( 0 );
}
lua_moo::luaNewState( mL );
lua_sethook( mL, &lua_task::luaHook, LUA_MASKCOUNT, 10 );
}
return( mL );
}
static const char TaskLuaKey = 'k';
lua_task *lua_task::luaGetTask( lua_State *L )
{
lua_pushlightuserdata( L, (void *)&TaskLuaKey );
lua_gettable( L, LUA_REGISTRYINDEX );
lua_task *T = reinterpret_cast<lua_task *>( lua_touserdata( L, -1 ) );
lua_pop( L, 1 );
return( T );
}
void lua_task::luaSetTask( lua_State *L, lua_task *T )
{
lua_pushlightuserdata( L, (void *)&TaskLuaKey );
lua_pushlightuserdata( L, T );
lua_settable( L, LUA_REGISTRYINDEX );
}
void *lua_task::luaAlloc( void *ptr, size_t osize, size_t nsize )
{
mMemUse -= osize;
if( nsize == 0 )
{
free(ptr);
return NULL;
}
mMemUse += nsize;
return realloc(ptr, nsize);
}
void *lua_task::luaAlloc( void *ud, void *ptr, size_t osize, size_t nsize )
{
return( static_cast<lua_task *>( ud )->luaAlloc( ptr, osize, nsize ) );
}
int lua_task::execute( qint64 pTimeStamp )
{
Connection *C = ConnectionManager::instance()->connection( connectionid() );
Task &T = mTasks.front();
if( C != 0 && C->processInput( T.command() ) )
{
return( 0 );
}
QString ArgStr;
QStringList Words = Verb::parse( T.command(), ArgStr );
const QString First = ( Words.isEmpty() ? "" : Words.takeFirst() );
mTimeStamp = pTimeStamp;
// the server next checks to see if the first word names any of the six "built-in" commands:
// `.program', `PREFIX', `OUTPUTPREFIX', `SUFFIX', `OUTPUTSUFFIX',
// or the connection's defined flush command, if any (`.flush' by default).
T.setCaller( T.player() );
T.setVerb( First );
T.setArgStr( ArgStr );
T.setArgs( Words );
// check for the built-in commands
if( First == "PREFIX" || First == "OUTPUTPREFIX" )
{
if( C != 0 )
{
if( !Words.isEmpty() )
{
C->setPrefix( Words.at( 0 ) );
}
else
{
C->setPrefix( "" );
}
}
return( 0 );
}
else if( First == "SUFFIX" || First == "OUTPUTSUFFIX" )
{
if( C != 0 )
{
if( !Words.isEmpty() )
{
C->setSuffix( Words.at( 0 ) );
}
else
{
C->setSuffix( "" );
}
}
return( 0 );
}
else if( First == ".flush" )
{
return( 0 );
}
// We're processing a normal command from the user
if( mL == 0 )
{
if( ( mL = lua_newstate( lua_task::luaAlloc, this ) ) == 0 )
{
return( 0 );
}
lua_moo::luaNewState( mL );
lua_sethook( mL, &lua_task::luaHook, LUA_MASKCOUNT, 10 );
}
if( ObjectManager::instance()->maxId() == 0 )
{
ObjectManager::instance()->luaMinimal();
}
luaSetTask( mL, this );
if( C != 0 && C->player() == OBJECT_NONE )
{
return( executeLogin() );
}
return( execute() );
}
int lua_task::eval( void )
{
if( mL == 0 )
{
if( ( mL = lua_newstate( lua_task::luaAlloc, this ) ) == 0 )
{
return( 0 );
}
lua_moo::luaNewState( mL );
lua_sethook( mL, &lua_task::luaHook, LUA_MASKCOUNT, 10 );
luaSetTask( mL, this );
}
Task &T = mTasks.front();
const int OldTop = lua_gettop( mL );
int Error;
if( ( Error = luaL_loadstring( mL, T.command().toLatin1() ) ) == 0 )
{
lua_moo::luaSetEnv( mL );
if( ( Error = lua_pcall( mL, 0, LUA_MULTRET, 0 ) ) == 0 )
{
}
}
if( Error != 0 )
{
QString Err = QString( lua_tostring( mL, -1 ) );
Connection *CON = ConnectionManager::instance()->connection( connectionid() );
if( CON )
{
CON->notify( Err );
}
else
{
qDebug() << Err;
}
lua_pop( mL, 1 );
}
const int NewTop = lua_gettop( mL );
return( NewTop - OldTop );
}
int lua_task::executeLogin( void )
{
// bool LuaErr = false;
try
{
Task &T = mTasks.front();
ObjectManager &OM = *ObjectManager::instance();
Object *Root = OM.object( 0 );
Verb *LoginCommand = ( Root != 0 ? Root->verbMatch( "do_login_command" ) : 0 );
ObjectId MaxId = OM.maxId();
Verb *V;
if( LoginCommand == 0 )
{
return( 0 );
}
T.setProgrammer( Root->owner() );
if( verbCall( Root->id(), LoginCommand ) != 1 )
{
lua_pop( mL, std::max<int>( 0, lua_gettop( mL ) ) );
Q_ASSERT( lua_gettop( mL ) == 0 );
return( 0 );
}
Object *Player = lua_object::argObj( mL, -1 );
lua_pop( mL, 1 );
Q_ASSERT( lua_gettop( mL ) == 0 );
if( Player == 0 )
{
return( 0 );
}
if( !Player->player() )
{
return( 0 );
}
ConnectionManager &CM = *ConnectionManager::instance();
const ConnectionNodeMap &NM = CM.connectionList();
bool UR = false;
for( ConnectionNodeMap::const_iterator it = NM.begin() ; it != NM.end() ; it++ )
{
Connection *C = it.value();
if( C->player() == Player->id() )
{
if( C->object() != 0 )
{
if( ( V = Root->verbMatch( "user_client_disconnected" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
else
{
UR = true;
}
C->setPlayerId( OBJECT_NONE );
}
}
CM.logon( connectionid(), Player->id() );
Player->setConnection( connectionid() );
T.setPlayer( Player->id() );
if( OM.maxId() > MaxId )
{
if( ( V = Root->verbMatch( "user_created" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
else if( UR )
{
if( ( V = Root->verbMatch( "user_reconnected" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
else
{
if( ( V = Root->verbMatch( "user_connected" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
}
catch( mooException e )
{
e.lua_pushexception( mL );
LuaErr = true;
}
catch( ... )
{
}
return( lua_gettop( mL ) );
}
int lua_task::execute( void )
{
// bool LuaErr = false;
try
{
Task &T = mTasks.front();
Connection *C = ConnectionManager::instance()->connection( connectionid() );
ObjectManager &OM = *ObjectManager::instance();
// The server next gives code in the database a chance to handle the command.
// If the verb $do_command() exists, it is called with the words of the command passed as its
// arguments and argstr set to the raw command typed by the user.
// If $do_command() does not exist, or if that verb-call completes normally (i.e., without
// suspending or aborting) and returns a false value, then the built-in command parser is
// invoked to handle the command as described below.
Object *Root = OM.object( 0 );
Verb *DoCommand = ( Root ? Root->verbMatch( "do_command" ) : 0 );
if( DoCommand && verbCall( *Root, DoCommand ) == 1 && lua_toboolean( mL, -1 ) )
{
return( lua_gettop( mL ) );
}
// Otherwise, it is assumed that the database code handled the command completely and no further
// action is taken by the server for that command.
// The first word is taken to be the verb
// The server then tries to find one of the prepositional phrases using the match that occurs
// earliest in the command.
int PrpIdx = T.findPreposition( T.args() );
// If the server succeeds in finding a preposition, it considers the words between
// the verb and the preposition to be the direct object and those after the preposition
// to be the indirect object.
// If there was no preposition, then the direct object is taken to be all of the words after
// the verb and the indirect object is the empty string.
T.getDirectAndIndirect( T.args(), PrpIdx );
// The next step is to try to find MOO objects that are named by the
// direct and indirect object strings.
// First, if an object string is empty, then the corresponding object is the special object #-1
// (aka $nothing in LambdaCore)
// If an object string has the form of an object number (i.e., a hash mark (`#') followed by digits),
// and the object with that number exists, then that is the named object.
// If the object string is either "me" or "here", then the player object itself or its location
// is used, respectively.
QList<ObjectId> ObjectIdList;
if( T.directObjectName().isEmpty() )
{
T.setDirectObjectId( OBJECT_NONE );
}
else
{
T.setDirectObjectId( OBJECT_FAILED_MATCH );
T.findObject( T.directObjectName(), ObjectIdList );
if( ObjectIdList.size() > 1 )
{
T.setDirectObjectId( OBJECT_AMBIGUOUS );
}
else if( !ObjectIdList.isEmpty() )
{
T.setDirectObjectId( ObjectIdList.at( 0 ) );
}
ObjectIdList.clear();
}
if( T.indirectObjectName().isEmpty() )
{
T.setIndirectObjectId( OBJECT_NONE );
}
else
{
T.setIndirectObjectId( OBJECT_FAILED_MATCH );
T.findObject( T.indirectObjectName(), ObjectIdList );
if( ObjectIdList.size() > 1 )
{
T.setDirectObjectId( OBJECT_AMBIGUOUS );
}
else if( !ObjectIdList.isEmpty() )
{
T.setIndirectObjectId( ObjectIdList.at( 0 ) );
}
ObjectIdList.clear();
}
// It then looks at each of the verbs defined on each of the following four objects, in order:
// 1. the player who typed the command
// 2. the room the player is in
// 3. the direct object, if any
// 4. the indirect object, if any
Object *Player = OM.object( T.player() );
Object *Location = ( Player != 0 ? OM.object( Player->location() ) : 0 );
ObjectId DirectObjectId = T.directObjectId();
ObjectId IndirectObjectId = T.indirectObjectId();
Object *DirectObject = OM.object( DirectObjectId );
Object *IndirectObject = OM.object( IndirectObjectId );
Verb *FndVrb;
Object *FndObj;
if( Player && Player->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( Player->id() );
}
else if( Location && Location->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( Location->id() );
}
else if( DirectObject && DirectObject->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( DirectObject->id() );
}
else if( IndirectObject && IndirectObject->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( IndirectObject->id() );
}
else if( Location && Location->verbFind( "huh", &FndVrb, &FndObj ) )
{
T.setObject( Location->id() );
}
else
{
if( C != 0 )
{
C->notify( "I couldn't understand that." );
}
return( 0 );
}
T.setObject( FndVrb->object() );
/*
player an object, the player who typed the command
this an object, the object on which this verb was found
caller an object, the same as `player'
verb a string, the first word of the command
argstr a string, everything after the first word of the command
args a list of strings, the words in `argstr'
dobjstr a string, the direct object string found during parsing
dobj an object, the direct object value found during matching
prepstr a string, the prepositional phrase found during parsing
iobjstr a string, the indirect object string
iobj an object, the indirect object value
*/
// The owner of a verb also determines the permissions with which that
// verb runs; that is, the program in a verb can do whatever operations
// the owner of that verb is allowed to do and no others.
T.setProgrammer( FndVrb->owner() );
return( verbCallCode( FndVrb ) );
}
catch( mooException e )
{
e.lua_pushexception( mL );
LuaErr = true;
}
catch( ... )
{
}
return( lua_gettop( mL ) );
}
int lua_task::verbCall( ObjectId pObjectId, Verb *V, int pArgCnt )
{
Task T = task();
T.setProgrammer( V->owner() );
T.setCaller( T.object() );
T.setObject( pObjectId );
return( verbCall( T, V, pArgCnt ) );
}
int lua_task::verbCall( Task &pTask, Verb *V, int pArgCnt )
{
int Result;
taskPush( pTask );
Result = verbCallCode( V, pArgCnt );
taskPop();
return( Result );
}
int lua_task::verbCallCode( Verb *V, int pArgCnt )
{
Connection *C = ConnectionManager::instance()->connection( connectionid() );
int c1 = lua_gettop( mL );
int Error;
//lua_moo::stackDump( mL );
if( ( Error = V->lua_pushverb( mL ) ) == 0 )
{
//lua_moo::luaSetEnv( mL );
lua_getfenv( mL, -1 );
lua_newtable( mL );
for( int i = 0 ; i < pArgCnt ; i++ )
{
lua_pushinteger( mL, i + 1 );
lua_pushvalue( mL, -4 - pArgCnt + i );
//lua_moo::stackDump( mL );
lua_settable( mL, -3 );
}
lua_setfield( mL, -2, "args" );
lua_pop( mL, 1 ); // remove environment
//lua_moo::stackDump( mL );
if( ( Error = lua_pcall( mL, 0, LUA_MULTRET, 0 ) ) == 0 )
{
}
}
if( Error != 0 )
{
//qDebug() << lua_tostring( mL, -1 );
if( C != 0 )
{
C->notify( lua_tostring( mL, -1 ) );
}
lua_pop( mL, 1 );
}
int c2 = lua_gettop( mL );
//lua_moo::stackDump( mL ); std::cout.flush();
return( c2 - c1 );
}
void lua_task::taskPush( const Task &T )
{
mTasks.push_front( T );
}
void lua_task::taskPop()
{
mTasks.pop_front();
}
void lua_task::luaHook( lua_State *L, lua_Debug *ar )
{
if( ar->event == LUA_HOOKCOUNT )
{
lua_task *T = lua_task::luaGetTask( L );
if( T != 0 )
{
if( QDateTime::currentMSecsSinceEpoch() - T->timestamp() > 5000 )
{
//luaL_error( L, "function is taking too long" );
//qDebug() << "function is taking too long";
}
}
}
}
int lua_task::throwError( mooError pError, const QString pMessage )
{
Q_UNUSED( pError )
Q_UNUSED( pMessage )
//qDebug() << "error:" << pError << pMessage;
//throw( mooException( pError, pMessage ) );
return( 0 );
}
Fixed error exceptions in execute
#include <QDateTime>
#include <QDebug>
#include "lua_task.h"
#include "task.h"
#include "objectmanager.h"
#include "connection.h"
#include "lua_moo.h"
#include "lua_object.h"
#include "lua_verb.h"
#include "lua_connection.h"
#include "verb.h"
#include "mooexception.h"
#include "connectionmanager.h"
#include "taskentry.h"
#include "inputsinkprogram.h"
#include <iostream>
const luaL_Reg lua_task::mLuaStatic[] =
{
{ "task", lua_task::luaTask },
{ "kill", lua_task::luaKill },
{ 0, 0 }
};
const luaL_Reg lua_task::mLuaGet[] =
{
{ "object", lua_task::luaObject },
{ "verb", lua_task::luaVerb },
{ "args", lua_task::luaArgs },
{ "argstr", lua_task::luaArgStr },
{ "caller", lua_task::luaCaller },
{ "here", lua_task::luaHere },
{ "me", lua_task::luaMe },
{ "player", lua_task::luaPlayer },
{ "dobj", lua_task::luaDirectObject },
{ "dobjstr", lua_task::luaDirectObjectString },
{ "iobj", lua_task::luaIndirectObject },
{ "iobjstr", lua_task::luaIndirectObjectString },
{ "prepstr", lua_task::luaPreposition },
{ "programmer", lua_task::luaGetProgrammer },
{ 0, 0 }
};
const luaL_Reg lua_task::mLuaSet[] =
{
{ "programmer", lua_task::luaSetProgrammer },
{ 0, 0 }
};
void lua_task::initialise()
{
lua_moo::addFunctions( mLuaStatic );
lua_moo::addGet( mLuaGet );
lua_moo::addSet( mLuaSet );
}
void lua_task::luaRegisterState( lua_State *L )
{
Q_UNUSED( L )
}
int lua_task::luaObject( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.object() );
return( 1 );
}
int lua_task::luaVerb( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.verb().toLatin1() );
return( 1 );
}
int lua_task::luaArgs( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
const QStringList &W = T.args();
lua_newtable( L );
for( int i = 0 ; i < W.size() ; i++ )
{
lua_pushinteger( L, i + 1 );
lua_pushstring( L, W.at( i ).toLatin1() );
lua_settable( L, -3 );
}
return( 1 );
}
int lua_task::luaArgStr(lua_State *L)
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.argstr().toLatin1() );
return( 1 );
}
int lua_task::luaCaller( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.caller() );
return( 1 );
}
int lua_task::luaPlayer( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.player() );
return( 1 );
}
int lua_task::luaHere( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
Object *O = ObjectManager::o( T.player() );
lua_object::lua_pushobjectid( L, O == 0 ? OBJECT_NONE : O->location() );
return( 1 );
}
int lua_task::luaMe( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.player() );
return( 1 );
}
int lua_task::luaTask( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
luaL_checkinteger( L, 1 );
luaL_checkstring( L, 2 );
lua_task *lt = lua_task::luaGetTask( L );
TaskEntry E( QString( lua_tostring( L, 2 ) ), lt->connectionid(), T.programmer() );
E.setTimeStamp( E.timestamp() + ( lua_tonumber( L, 1 ) * 1000.0 ) );
ObjectManager::instance()->queueTask( E );
lua_pushinteger( L, E.id() );
return( 1 );
}
int lua_task::luaKill(lua_State *L)
{
luaL_checkinteger( L, 1 );
TaskId tid = lua_tointeger( L, 1 );
lua_pushboolean( L, ObjectManager::instance()->killTask( tid ) );
return( 1 );
}
int lua_task::luaDirectObject( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.directObjectId() );
return( 1 );
}
int lua_task::luaDirectObjectString(lua_State *L)
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.directObjectName().toUtf8() );
return( 1 );
}
int lua_task::luaIndirectObject( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_object::lua_pushobjectid( L, T.indirectObjectId() );
return( 1 );
}
int lua_task::luaIndirectObjectString(lua_State *L)
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.indirectObjectName().toUtf8() );
return( 1 );
}
int lua_task::luaPreposition( lua_State *L )
{
const Task &T = lua_task::luaGetTask( L )->task();
lua_pushstring( L, T.preposition().toUtf8() );
return( 1 );
}
int lua_task::luaGetProgrammer( lua_State *L )
{
const lua_task *LT = lua_task::luaGetTask( L );
lua_object::lua_pushobjectid( L, LT->programmer() );
return( 1 );
}
int lua_task::luaSetProgrammer( lua_State *L )
{
lua_task *LT = lua_task::luaGetTask( L );
ObjectId WID = lua_object::argId( L, -1 );
Object *PRG = ObjectManager::o( LT->programmer() );
if( PRG->id() == WID || PRG->wizard() )
{
LT->setProgrammer( WID );
}
else
{
luaL_error( L, "bad permissions" );
}
return( 0 );
}
lua_task::lua_task( ConnectionId pConnectionId, const Task &pTask )
: mL( 0 ), mConnectionId( pConnectionId ), mMemUse( 0 )
{
mTasks.push_front( pTask );
}
lua_task::~lua_task( void )
{
if( mL != 0 )
{
lua_close( mL );
mL = 0;
}
}
lua_State *lua_task::L()
{
if( mL == 0 )
{
if( ( mL = lua_newstate( lua_task::luaAlloc, this ) ) == 0 )
{
return( 0 );
}
lua_moo::luaNewState( mL );
lua_sethook( mL, &lua_task::luaHook, LUA_MASKCOUNT, 10 );
}
return( mL );
}
static const char TaskLuaKey = 'k';
lua_task *lua_task::luaGetTask( lua_State *L )
{
lua_pushlightuserdata( L, (void *)&TaskLuaKey );
lua_gettable( L, LUA_REGISTRYINDEX );
lua_task *T = reinterpret_cast<lua_task *>( lua_touserdata( L, -1 ) );
lua_pop( L, 1 );
return( T );
}
void lua_task::luaSetTask( lua_State *L, lua_task *T )
{
lua_pushlightuserdata( L, (void *)&TaskLuaKey );
lua_pushlightuserdata( L, T );
lua_settable( L, LUA_REGISTRYINDEX );
}
void *lua_task::luaAlloc( void *ptr, size_t osize, size_t nsize )
{
mMemUse -= osize;
if( nsize == 0 )
{
free(ptr);
return NULL;
}
mMemUse += nsize;
return realloc(ptr, nsize);
}
void *lua_task::luaAlloc( void *ud, void *ptr, size_t osize, size_t nsize )
{
return( static_cast<lua_task *>( ud )->luaAlloc( ptr, osize, nsize ) );
}
int lua_task::execute( qint64 pTimeStamp )
{
Connection *C = ConnectionManager::instance()->connection( connectionid() );
Task &T = mTasks.front();
if( C != 0 && C->processInput( T.command() ) )
{
return( 0 );
}
QString ArgStr;
QStringList Words = Verb::parse( T.command(), ArgStr );
const QString First = ( Words.isEmpty() ? "" : Words.takeFirst() );
mTimeStamp = pTimeStamp;
// the server next checks to see if the first word names any of the six "built-in" commands:
// `.program', `PREFIX', `OUTPUTPREFIX', `SUFFIX', `OUTPUTSUFFIX',
// or the connection's defined flush command, if any (`.flush' by default).
T.setCaller( T.player() );
T.setVerb( First );
T.setArgStr( ArgStr );
T.setArgs( Words );
// check for the built-in commands
if( First == "PREFIX" || First == "OUTPUTPREFIX" )
{
if( C != 0 )
{
if( !Words.isEmpty() )
{
C->setPrefix( Words.at( 0 ) );
}
else
{
C->setPrefix( "" );
}
}
return( 0 );
}
else if( First == "SUFFIX" || First == "OUTPUTSUFFIX" )
{
if( C != 0 )
{
if( !Words.isEmpty() )
{
C->setSuffix( Words.at( 0 ) );
}
else
{
C->setSuffix( "" );
}
}
return( 0 );
}
else if( First == ".flush" )
{
return( 0 );
}
// We're processing a normal command from the user
if( mL == 0 )
{
if( ( mL = lua_newstate( lua_task::luaAlloc, this ) ) == 0 )
{
return( 0 );
}
lua_moo::luaNewState( mL );
lua_sethook( mL, &lua_task::luaHook, LUA_MASKCOUNT, 10 );
}
if( ObjectManager::instance()->maxId() == 0 )
{
ObjectManager::instance()->luaMinimal();
}
luaSetTask( mL, this );
if( C != 0 && C->player() == OBJECT_NONE )
{
return( executeLogin() );
}
return( execute() );
}
int lua_task::eval( void )
{
if( mL == 0 )
{
if( ( mL = lua_newstate( lua_task::luaAlloc, this ) ) == 0 )
{
return( 0 );
}
lua_moo::luaNewState( mL );
lua_sethook( mL, &lua_task::luaHook, LUA_MASKCOUNT, 10 );
luaSetTask( mL, this );
}
Task &T = mTasks.front();
const int OldTop = lua_gettop( mL );
int Error;
if( ( Error = luaL_loadstring( mL, T.command().toLatin1() ) ) == 0 )
{
lua_moo::luaSetEnv( mL );
if( ( Error = lua_pcall( mL, 0, LUA_MULTRET, 0 ) ) == 0 )
{
}
}
if( Error != 0 )
{
QString Err = QString( lua_tostring( mL, -1 ) );
Connection *CON = ConnectionManager::instance()->connection( connectionid() );
if( CON )
{
CON->notify( Err );
}
else
{
qDebug() << Err;
}
lua_pop( mL, 1 );
}
const int NewTop = lua_gettop( mL );
return( NewTop - OldTop );
}
int lua_task::executeLogin( void )
{
bool LuaErr = false;
try
{
Task &T = mTasks.front();
ObjectManager &OM = *ObjectManager::instance();
Object *Root = OM.object( 0 );
Verb *LoginCommand = ( Root != 0 ? Root->verbMatch( "do_login_command" ) : 0 );
ObjectId MaxId = OM.maxId();
Verb *V;
if( LoginCommand == 0 )
{
return( 0 );
}
T.setProgrammer( Root->owner() );
if( verbCall( Root->id(), LoginCommand ) != 1 )
{
lua_pop( mL, std::max<int>( 0, lua_gettop( mL ) ) );
Q_ASSERT( lua_gettop( mL ) == 0 );
return( 0 );
}
Object *Player = lua_object::argObj( mL, -1 );
lua_pop( mL, 1 );
Q_ASSERT( lua_gettop( mL ) == 0 );
if( Player == 0 )
{
return( 0 );
}
if( !Player->player() )
{
return( 0 );
}
ConnectionManager &CM = *ConnectionManager::instance();
const ConnectionNodeMap &NM = CM.connectionList();
bool UR = false;
for( ConnectionNodeMap::const_iterator it = NM.begin() ; it != NM.end() ; it++ )
{
Connection *C = it.value();
if( C->player() == Player->id() )
{
if( C->object() != 0 )
{
if( ( V = Root->verbMatch( "user_client_disconnected" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
else
{
UR = true;
}
C->setPlayerId( OBJECT_NONE );
}
}
CM.logon( connectionid(), Player->id() );
Player->setConnection( connectionid() );
T.setPlayer( Player->id() );
if( OM.maxId() > MaxId )
{
if( ( V = Root->verbMatch( "user_created" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
else if( UR )
{
if( ( V = Root->verbMatch( "user_reconnected" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
else
{
if( ( V = Root->verbMatch( "user_connected" ) ) != 0 )
{
lua_object::lua_pushobject( mL, Player );
verbCall( Root->id(), V, 1 );
}
}
}
catch( mooException e )
{
e.lua_pushexception( mL );
LuaErr = true;
}
catch( ... )
{
}
return( LuaErr ? lua_error( mL ) : lua_gettop( mL ) );
}
int lua_task::execute( void )
{
bool LuaErr = false;
try
{
Task &T = mTasks.front();
Connection *C = ConnectionManager::instance()->connection( connectionid() );
ObjectManager &OM = *ObjectManager::instance();
// The server next gives code in the database a chance to handle the command.
// If the verb $do_command() exists, it is called with the words of the command passed as its
// arguments and argstr set to the raw command typed by the user.
// If $do_command() does not exist, or if that verb-call completes normally (i.e., without
// suspending or aborting) and returns a false value, then the built-in command parser is
// invoked to handle the command as described below.
Object *Root = OM.object( 0 );
Verb *DoCommand = ( Root ? Root->verbMatch( "do_command" ) : 0 );
if( DoCommand && verbCall( *Root, DoCommand ) == 1 && lua_toboolean( mL, -1 ) )
{
return( lua_gettop( mL ) );
}
// Otherwise, it is assumed that the database code handled the command completely and no further
// action is taken by the server for that command.
// The first word is taken to be the verb
// The server then tries to find one of the prepositional phrases using the match that occurs
// earliest in the command.
int PrpIdx = T.findPreposition( T.args() );
// If the server succeeds in finding a preposition, it considers the words between
// the verb and the preposition to be the direct object and those after the preposition
// to be the indirect object.
// If there was no preposition, then the direct object is taken to be all of the words after
// the verb and the indirect object is the empty string.
T.getDirectAndIndirect( T.args(), PrpIdx );
// The next step is to try to find MOO objects that are named by the
// direct and indirect object strings.
// First, if an object string is empty, then the corresponding object is the special object #-1
// (aka $nothing in LambdaCore)
// If an object string has the form of an object number (i.e., a hash mark (`#') followed by digits),
// and the object with that number exists, then that is the named object.
// If the object string is either "me" or "here", then the player object itself or its location
// is used, respectively.
QList<ObjectId> ObjectIdList;
if( T.directObjectName().isEmpty() )
{
T.setDirectObjectId( OBJECT_NONE );
}
else
{
T.setDirectObjectId( OBJECT_FAILED_MATCH );
T.findObject( T.directObjectName(), ObjectIdList );
if( ObjectIdList.size() > 1 )
{
T.setDirectObjectId( OBJECT_AMBIGUOUS );
}
else if( !ObjectIdList.isEmpty() )
{
T.setDirectObjectId( ObjectIdList.at( 0 ) );
}
ObjectIdList.clear();
}
if( T.indirectObjectName().isEmpty() )
{
T.setIndirectObjectId( OBJECT_NONE );
}
else
{
T.setIndirectObjectId( OBJECT_FAILED_MATCH );
T.findObject( T.indirectObjectName(), ObjectIdList );
if( ObjectIdList.size() > 1 )
{
T.setDirectObjectId( OBJECT_AMBIGUOUS );
}
else if( !ObjectIdList.isEmpty() )
{
T.setIndirectObjectId( ObjectIdList.at( 0 ) );
}
ObjectIdList.clear();
}
// It then looks at each of the verbs defined on each of the following four objects, in order:
// 1. the player who typed the command
// 2. the room the player is in
// 3. the direct object, if any
// 4. the indirect object, if any
Object *Player = OM.object( T.player() );
Object *Location = ( Player != 0 ? OM.object( Player->location() ) : 0 );
ObjectId DirectObjectId = T.directObjectId();
ObjectId IndirectObjectId = T.indirectObjectId();
Object *DirectObject = OM.object( DirectObjectId );
Object *IndirectObject = OM.object( IndirectObjectId );
Verb *FndVrb;
Object *FndObj;
if( Player && Player->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( Player->id() );
}
else if( Location && Location->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( Location->id() );
}
else if( DirectObject && DirectObject->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( DirectObject->id() );
}
else if( IndirectObject && IndirectObject->verbFind( T.verb(), &FndVrb, &FndObj, DirectObjectId, T.preposition(), IndirectObjectId ) )
{
T.setObject( IndirectObject->id() );
}
else if( Location && Location->verbFind( "huh", &FndVrb, &FndObj ) )
{
T.setObject( Location->id() );
}
else
{
if( C != 0 )
{
C->notify( "I couldn't understand that." );
}
return( 0 );
}
T.setObject( FndVrb->object() );
/*
player an object, the player who typed the command
this an object, the object on which this verb was found
caller an object, the same as `player'
verb a string, the first word of the command
argstr a string, everything after the first word of the command
args a list of strings, the words in `argstr'
dobjstr a string, the direct object string found during parsing
dobj an object, the direct object value found during matching
prepstr a string, the prepositional phrase found during parsing
iobjstr a string, the indirect object string
iobj an object, the indirect object value
*/
// The owner of a verb also determines the permissions with which that
// verb runs; that is, the program in a verb can do whatever operations
// the owner of that verb is allowed to do and no others.
T.setProgrammer( FndVrb->owner() );
return( verbCallCode( FndVrb ) );
}
catch( mooException e )
{
e.lua_pushexception( mL );
LuaErr = true;
}
catch( ... )
{
}
return( LuaErr ? lua_error( mL ) : lua_gettop( mL ) );
}
int lua_task::verbCall( ObjectId pObjectId, Verb *V, int pArgCnt )
{
Task T = task();
T.setProgrammer( V->owner() );
T.setCaller( T.object() );
T.setObject( pObjectId );
return( verbCall( T, V, pArgCnt ) );
}
int lua_task::verbCall( Task &pTask, Verb *V, int pArgCnt )
{
int Result;
taskPush( pTask );
Result = verbCallCode( V, pArgCnt );
taskPop();
return( Result );
}
int lua_task::verbCallCode( Verb *V, int pArgCnt )
{
Connection *C = ConnectionManager::instance()->connection( connectionid() );
int c1 = lua_gettop( mL );
int Error;
//lua_moo::stackDump( mL );
if( ( Error = V->lua_pushverb( mL ) ) == 0 )
{
//lua_moo::luaSetEnv( mL );
lua_getfenv( mL, -1 );
lua_newtable( mL );
for( int i = 0 ; i < pArgCnt ; i++ )
{
lua_pushinteger( mL, i + 1 );
lua_pushvalue( mL, -4 - pArgCnt + i );
//lua_moo::stackDump( mL );
lua_settable( mL, -3 );
}
lua_setfield( mL, -2, "args" );
lua_pop( mL, 1 ); // remove environment
//lua_moo::stackDump( mL );
if( ( Error = lua_pcall( mL, 0, LUA_MULTRET, 0 ) ) == 0 )
{
}
}
if( Error != 0 )
{
//qDebug() << lua_tostring( mL, -1 );
if( C != 0 )
{
C->notify( lua_tostring( mL, -1 ) );
}
lua_pop( mL, 1 );
}
int c2 = lua_gettop( mL );
//lua_moo::stackDump( mL ); std::cout.flush();
return( c2 - c1 );
}
void lua_task::taskPush( const Task &T )
{
mTasks.push_front( T );
}
void lua_task::taskPop()
{
mTasks.pop_front();
}
void lua_task::luaHook( lua_State *L, lua_Debug *ar )
{
if( ar->event == LUA_HOOKCOUNT )
{
lua_task *T = lua_task::luaGetTask( L );
if( T != 0 )
{
if( QDateTime::currentMSecsSinceEpoch() - T->timestamp() > 5000 )
{
//luaL_error( L, "function is taking too long" );
//qDebug() << "function is taking too long";
}
}
}
}
int lua_task::throwError( mooError pError, const QString pMessage )
{
Q_UNUSED( pError )
Q_UNUSED( pMessage )
//qDebug() << "error:" << pError << pMessage;
//throw( mooException( pError, pMessage ) );
return( 0 );
}
|
/***********************************************************************
test_manip.cpp - Tests the quoting and escaping manipulators.
Copyright (c) 2007 by Educational Technology Resources, Inc.
Others may also hold copyrights on code in this file. See the
CREDITS file in the top directory of the distribution for details.
This file is part of MySQL++.
MySQL++ is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
MySQL++ is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public
License along with MySQL++; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
USA
***********************************************************************/
#include <mysql++.h>
#include <iostream>
#include <sstream>
#include <string>
template <class T>
static bool
is_quoted(const std::string& s, T orig_str, size_t orig_len)
{
return (s.length() == (orig_len + 2)) &&
(s.at(0) == '\'') &&
(s.at(orig_len + 1) == '\'') &&
(s.compare(1, orig_len, orig_str) == 0);
}
// Stringish types should be quoted when inserted into Query when an
// explicit quote manipulator is used.
template <class T>
static bool
test_explicit_query_quote(mysqlpp::Query& q, T test, size_t len)
{
q.reset();
q << mysqlpp::quote << test;
if (is_quoted(q.str(), test, len)) {
return true;
}
else {
std::cerr << "Explicit quote of " << typeid(test).name() <<
" in Query failed: " << q.str() << std::endl;
return false;
}
}
// Stringish types should be quoted when inserted into an ostream when
// an explicit quote manipulator is used.
template <class T>
static bool
test_explicit_ostream_quote(T test, size_t len)
{
std::ostringstream outs;
outs << mysqlpp::quote << test;
if (is_quoted(outs.str(), test, len)) {
return true;
}
else {
std::cerr << "Explicit quote of " << typeid(test).name() <<
" in ostream failed: " << outs.str() << std::endl;
return false;
}
}
// Stringish types should be implicitly quoted when inserted into Query
template <class T>
static bool
test_implicit_query_quote(mysqlpp::Query& q, T test, size_t len)
{
q.reset();
q << test;
if (is_quoted(q.str(), test, len)) {
return true;
}
else {
std::cerr << "Implicit quote of " << typeid(test).name() <<
" in Query failed: " << q.str() << std::endl;
return false;
}
}
// Stringish types should NOT be implicitly quoted when inserted into
// non-Query ostreams
template <class T>
static bool
fail_implicit_ostream_quote(T test, size_t len)
{
std::ostringstream outs;
outs << mysqlpp::quote << test;
if (!is_quoted(outs.str(), test, len)) {
return true;
}
else {
std::cerr << "Erroneously quoted " << typeid(test).name() <<
" in non-Query ostream: " << outs.str() << std::endl;
return false;
}
}
// Run all tests above for the given type
template <class T>
static bool
test(mysqlpp::Query& q, T test, size_t len)
{
return test_explicit_query_quote(q, test, len) &&
test_explicit_ostream_quote(test, len) &&
test_implicit_query_quote(q, test, len) &&
!fail_implicit_ostream_quote(test, len);
}
int
main()
{
mysqlpp::Connection c;
mysqlpp::Query q(&c);
char s[] = "Doodle me, James, doodle me!";
const size_t len = strlen(s);
int failures = 0;
failures += test(q, s, len) == false;
failures += test(q, (char*)s, len) == false;
failures += test(q, (const char*)s, len) == false;
failures += test(q, std::string(s), len) == false;
failures += test(q, mysqlpp::ColData(s), len) == false;
return failures;
}
test_manip now passes all tests. Earlier notion that these tests should
fail and the library needs changing was wrong. There are tests we could
write that should fail and which will pass when the proposed manipulator
changes are made, but these are not those.
git-svn-id: 1a57124bbb9aca193a920d0ffd753d488afb922b@1735 5946f024-35f4-0310-b1b3-9a3be3380cfb
/***********************************************************************
test_manip.cpp - Tests the quoting and escaping manipulators.
Copyright (c) 2007 by Educational Technology Resources, Inc.
Others may also hold copyrights on code in this file. See the
CREDITS file in the top directory of the distribution for details.
This file is part of MySQL++.
MySQL++ is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
MySQL++ is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
You should have received a copy of the GNU Lesser General Public
License along with MySQL++; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
USA
***********************************************************************/
#include <mysql++.h>
#include <iostream>
#include <sstream>
#include <string>
template <class T>
static bool
is_quoted(const std::string& s, T orig_str, size_t orig_len)
{
return (s.length() == (orig_len + 2)) &&
(s.at(0) == '\'') &&
(s.at(orig_len + 1) == '\'') &&
(s.compare(1, orig_len, orig_str) == 0);
}
// Stringish types should be quoted when inserted into Query when an
// explicit quote manipulator is used.
template <class T>
static bool
test_explicit_query_quote(mysqlpp::Query& q, T test, size_t len)
{
q.reset();
q << mysqlpp::quote << test;
if (is_quoted(q.str(), test, len)) {
return true;
}
else {
std::cerr << "Explicit quote of " << typeid(test).name() <<
" in Query failed: " << q.str() << std::endl;
return false;
}
}
// Stringish types should be quoted when inserted into an ostream when
// an explicit quote manipulator is used.
template <class T>
static bool
test_explicit_ostream_quote(T test, size_t len)
{
std::ostringstream outs;
outs << mysqlpp::quote << test;
if (is_quoted(outs.str(), test, len)) {
return true;
}
else {
std::cerr << "Explicit quote of " << typeid(test).name() <<
" in ostream failed: " << outs.str() << std::endl;
return false;
}
}
// The only stringish type that should be implicitly quoted when
// inserted into Query is ColData, and not always then; we don't know
// enough about anything else to make good automated choices.
template <class T>
static bool
test_implicit_query_quote(mysqlpp::Query& q, T test, size_t len)
{
q.reset();
q << test;
if (is_quoted(q.str(), test, len) ||
(typeid(test) != typeid(mysqlpp::ColData))) {
return true;
}
else {
std::cerr << "Implicit quote of " << typeid(test).name() <<
" in Query failed: " << q.str() << std::endl;
return false;
}
}
// Stringish types should NOT be implicitly quoted when inserted into
// non-Query ostreams
template <class T>
static bool
fail_implicit_ostream_quote(T test, size_t len)
{
std::ostringstream outs;
outs << mysqlpp::quote << test;
if (!is_quoted(outs.str(), test, len)) {
return true;
}
else {
std::cerr << "Erroneously quoted " << typeid(test).name() <<
" in non-Query ostream: " << outs.str() << std::endl;
return false;
}
}
// Run all tests above for the given type
template <class T>
static bool
test(mysqlpp::Query& q, T test, size_t len)
{
return test_explicit_query_quote(q, test, len) &&
test_explicit_ostream_quote(test, len) &&
test_implicit_query_quote(q, test, len) &&
!fail_implicit_ostream_quote(test, len);
}
int
main()
{
mysqlpp::Connection c;
mysqlpp::Query q(&c);
char s[] = "Doodle me, James, doodle me!";
const size_t len = strlen(s);
int failures = 0;
failures += test(q, s, len) == false;
failures += test(q, (char*)s, len) == false;
failures += test(q, (const char*)s, len) == false;
failures += test(q, std::string(s), len) == false;
failures += test(q, mysqlpp::ColData(s), len) == false;
return failures;
}
|
/**
* @file ESP8266.cpp
* @brief The implementation of class ESP8266.
* @author Wu Pengfei<pengfei.wu@itead.cc>
* @date 2015.02
*
* @par Copyright:
* Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version. \n\n
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "ESP8266.h"
#define RTOS_BASED_DELAY
#if defined(RTOS_BASED_DELAY)
#include <Arduino_FreeRTOS.h>
#endif
#define LOG_OUTPUT_DEBUG (0)
#define LOG_OUTPUT_DEBUG_PREFIX (0)
#define logDebug(arg)\
do {\
if (LOG_OUTPUT_DEBUG)\
{\
if (LOG_OUTPUT_DEBUG_PREFIX)\
{\
Serial.print("[LOG Debug: ");\
/*Serial.print((const char*)__FILE__);*/\
/*Serial.print(",");*/\
Serial.print((unsigned int)__LINE__);\
Serial.print(",");\
Serial.print((const char*)__FUNCTION__);\
Serial.print("] ");\
}\
Serial.println(arg);\
}\
} while(0)
#ifdef ESP8266_USE_SOFTWARE_SERIAL
ESP8266::ESP8266(SoftwareSerial &uart, uint32_t baud): m_puart(&uart)
{
m_puart->begin(baud);
rx_empty();
}
#else
ESP8266::ESP8266(HardwareSerial &uart, uint32_t baud): m_puart(&uart)
{
m_puart->begin(baud);
rx_empty();
}
#endif
bool ESP8266::kick(void)
{
return eAT();
}
bool ESP8266::restart(void)
{
//Serial.println("restart");
unsigned long start;
if (eATRST()) {
logDebug(millis());
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*2000));
#else
delay(2000);
#endif
logDebug(millis());
start = millis();
while (millis() - start < 3000) {
if (eAT()) {
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*1500));
#else
delay(1500); /* Waiting for stable */
#endif
return true;
}
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*100));
#else
delay(100);
#endif
}
}
return false;
}
/*
String ESP8266::getVersion(void)
{
String version;
eATGMR(version);
return version;
}
*/
char * ESP8266::getVersion(void)
{
static char version[256] = {0};
memset(version, 0, 256);
eATGMR(version);
return version;
}
bool ESP8266::setOprToStation(void)
{
uint8_t mode;
if (!qATCWMODE(&mode)) {
return false;
}
if (mode == 1) {
return true;
} else {
if (sATCWMODE(1) && restart()) {
return true;
} else {
return false;
}
}
}
bool ESP8266::setOprToSoftAP(void)
{
uint8_t mode;
if (!qATCWMODE(&mode)) {
return false;
}
if (mode == 2) {
return true;
} else {
if (sATCWMODE(2) && restart()) {
return true;
} else {
return false;
}
}
}
bool ESP8266::setOprToStationSoftAP(void)
{
uint8_t mode;
if (!qATCWMODE(&mode)) {
return false;
}
if (mode == 3) {
return true;
} else {
if (sATCWMODE(3) && restart()) {
return true;
} else {
return false;
}
}
}
String ESP8266::getAPList(void)
{
String list;
eATCWLAP(list);
return list;
}
bool ESP8266::joinAP(char * ssid, char * pwd)
{
return sATCWJAP(ssid, pwd);
}
bool ESP8266::enableClientDHCP(uint8_t mode, boolean enabled)
{
return sATCWDHCP(mode, enabled);
}
bool ESP8266::leaveAP(void)
{
return eATCWQAP();
}
bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
return sATCWSAP(ssid, pwd, chl, ecn);
}
String ESP8266::getJoinedDeviceIP(void)
{
String list;
eATCWLIF(list);
return list;
}
String ESP8266::getIPStatus(void)
{
String list;
eATCIPSTATUS(list);
return list;
}
char * ESP8266::getLocalIP(void)
{
static char list[256] = {0};
memset(list, 0, 256);
eATCIFSR(list);
return list;
}
bool ESP8266::enableMUX(void)
{
return sATCIPMUX(1);
}
bool ESP8266::disableMUX(void)
{
return sATCIPMUX(0);
}
bool ESP8266::createTCP(char * addr, uint32_t port)
{
return sATCIPSTARTSingle("TCP", addr, port);
}
//bool ESP8266::createTCP(String addr, uint32_t port)
//{
// return sATCIPSTARTSingle("TCP", addr, port);
//}
bool ESP8266::releaseTCP(void)
{
return eATCIPCLOSESingle();
}
bool ESP8266::registerUDP(String addr, uint32_t port)
{
return sATCIPSTARTSingle("UDP", addr, port);
}
bool ESP8266::unregisterUDP(void)
{
return eATCIPCLOSESingle();
}
bool ESP8266::createTCP(uint8_t mux_id, char * addr, uint32_t port)
{
logDebug(addr);
return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
}
//bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
//{
// logDebug(addr);
// return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
//}
bool ESP8266::releaseTCP(uint8_t mux_id)
{
return sATCIPCLOSEMulitple(mux_id);
}
bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
{
return sATCIPSTARTMultiple(mux_id, "UDP", addr, port);
}
bool ESP8266::unregisterUDP(uint8_t mux_id)
{
return sATCIPCLOSEMulitple(mux_id);
}
bool ESP8266::setTCPServerTimeout(uint32_t timeout)
{
return sATCIPSTO(timeout);
}
bool ESP8266::startTCPServer(uint32_t port)
{
if (sATCIPSERVER(1, port)) {
return true;
}
return false;
}
bool ESP8266::stopTCPServer(void)
{
sATCIPSERVER(0);
restart();
return false;
}
bool ESP8266::startServer(uint32_t port)
{
return startTCPServer(port);
}
bool ESP8266::stopServer(void)
{
return stopTCPServer();
}
bool ESP8266::send(const uint8_t *buffer, uint32_t len)
{
return sATCIPSENDSingle(buffer, len);
}
bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
{
return sATCIPSENDMultiple(mux_id, buffer, len);
}
uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
{
return recvPkg(buffer, buffer_size, NULL, timeout, NULL);
}
uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
{
uint8_t id;
uint32_t ret;
ret = recvPkg(buffer, buffer_size, NULL, timeout, &id);
if (ret > 0 && id == mux_id) {
return ret;
}
return 0;
}
uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
{
return recvPkg(buffer, buffer_size, NULL, timeout, coming_mux_id);
}
/*----------------------------------------------------------------------------*/
/* +IPD,<id>,<len>:<data> */
/* +IPD,<len>:<data> */
uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id)
{
String data;
char a;
int32_t index_PIPDcomma = -1;
int32_t index_colon = -1; /* : */
int32_t index_comma = -1; /* , */
int32_t len = -1;
int8_t id = -1;
bool has_data = false;
uint32_t ret;
unsigned long start;
uint32_t i;
if (buffer == NULL) {
return 0;
}
start = millis();
while (millis() - start < timeout) {
if(m_puart->available() > 0) {
a = m_puart->read();
data += a;
}
index_PIPDcomma = data.indexOf("+IPD,");
if (index_PIPDcomma != -1) {
index_colon = data.indexOf(':', index_PIPDcomma + 5);
if (index_colon != -1) {
index_comma = data.indexOf(',', index_PIPDcomma + 5);
/* +IPD,id,len:data */
if (index_comma != -1 && index_comma < index_colon) {
id = data.substring(index_PIPDcomma + 5, index_comma).toInt();
if (id < 0 || id > 4) {
return 0;
}
len = data.substring(index_comma + 1, index_colon).toInt();
if (len <= 0) {
return 0;
}
} else { /* +IPD,len:data */
len = data.substring(index_PIPDcomma + 5, index_colon).toInt();
if (len <= 0) {
return 0;
}
}
has_data = true;
break;
}
}
}
if (has_data) {
i = 0;
ret = len > buffer_size ? buffer_size : len;
start = millis();
while (millis() - start < 3000) {
while(m_puart->available() > 0 && i < ret) {
a = m_puart->read();
buffer[i++] = a;
}
if (i == ret) {
rx_empty();
if (data_len) {
*data_len = len;
}
if (index_comma != -1 && coming_mux_id) {
*coming_mux_id = id;
}
return ret;
}
}
}
return 0;
}
void ESP8266::rx_empty(void)
{
while(m_puart->available() > 0) {
m_puart->read();
}
}
String ESP8266::recvString(String target, uint32_t timeout)
{
String data;
char a;
unsigned long start = millis();
//Serial.print("<");
//Serial.print(start);
//Serial.println("< [ ");
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
data += a;
//Serial.write(a);
}
if (data.indexOf(target) != -1) {
break;
}
}
//Serial.print(data);
//Serial.print(" ] <");
//Serial.print(millis());
//Serial.println("<");
return data;
}
char * ESP8266::recvString(char * target, uint32_t timeout)
{
static char data[256] = {0};
memset(data,0,256);
logDebug(target);
int inx=0;
char * pdata1;//* pdata2,* pdata3;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
//data += a;
if(inx<256)
data[inx++] = a;
else
break;
}
pdata1 = strstr (data, target);
logDebug(pdata1);
//pdata2 = strstr (data, target2.c_str());
//pdata3 = strstr (data, target3.c_str());
if (NULL != pdata1) {
break;
} //else if (NULL != pdata2) {
// break;
//} else if (NULL != pdata3) {
// break;
//}
}
logDebug(data);
return data;
}
String ESP8266::recvString(String target1, String target2, uint32_t timeout)
{
String data;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
data += a;
}
if (data.indexOf(target1) != -1) {
break;
} else if (data.indexOf(target2) != -1) {
break;
}
}
return data;
}
char * ESP8266::recvString(char * target1, char * target2, uint32_t timeout)
{
static char data[256] = {0};
memset(data,0,256);
int inx=0;
char * pdata1, * pdata2;//,* pdata3;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
if(inx<256)
data[inx++] = a;
else
break;
}
logDebug(data);
pdata1 = strstr (data, target1);
logDebug(pdata1);
pdata2 = strstr (data, target2);
logDebug(pdata2);
//pdata3 = strstr (data, target3);
//logDebug(pdata1);
if (NULL != pdata1) {
break;
} else if (NULL != pdata2) {
break;
} //else if (NULL != pdata3) {
// break;
//}
}
logDebug(data);
return data;
}
String ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
{
String data;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
data += a;
}
if (data.indexOf(target1) != -1) {
break;
} else if (data.indexOf(target2) != -1) {
break;
} else if (data.indexOf(target3) != -1) {
break;
}
}
return data;
}
char * ESP8266::recvString(char * target1, char * target2, char * target3, uint32_t timeout)
{
static char data[256] = {0};
memset(data,0,256);
int inx=0;
char * pdata1, * pdata2,* pdata3;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
if(inx<256)
data[inx++] = a;
else
break;
}
logDebug(data);
pdata1 = strstr (data, target1);
logDebug(pdata1);
pdata2 = strstr (data, target2);
logDebug(pdata2);
pdata3 = strstr (data, target3);
logDebug(pdata3);
if (NULL != pdata1) {
break;
} else if (NULL != pdata2) {
break;
} else if (NULL != pdata3) {
break;
}
}
logDebug(data);
return data;
}
bool ESP8266::recvFind(String target, uint32_t timeout)
{
String data_tmp;
//Serial.println("char?");
//Serial.println(target);
data_tmp = recvString(target, timeout);
if (data_tmp.indexOf(target) != -1) {
return true;
}
return false;
}
bool ESP8266::recvFind(char * target, uint32_t timeout)
{
//char data[256] = {0}; // to be handled
//data = (char*)malloc(256);
char * pdata = NULL;
char * pdata_tmp = NULL;
//Serial.println("char"); // fine
//Serial.println(target); // fine
logDebug(target);
pdata = recvString(target, timeout);
logDebug(pdata);
//Serial.println("char2"); // fine
//Serial.println(pdata); // fine
pdata_tmp = strstr (pdata, target);
logDebug(pdata_tmp);
if (NULL != pdata_tmp) {
return true;
}
return false;
}
bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
{
String data_tmp;
data_tmp = recvString(target, timeout);
if (data_tmp.indexOf(target) != -1) {
int32_t index1 = data_tmp.indexOf(begin);
int32_t index2 = data_tmp.indexOf(end);
if (index1 != -1 && index2 != -1) {
index1 += begin.length();
data = data_tmp.substring(index1, index2);
return true;
}
}
data = "";
return false;
}
bool ESP8266::recvFindAndFilter(char * target, char * begin, char * end, char * data, uint32_t timeout)
{
//String data_tmp;
char * data_tmp;
char * pdata_tmp;
char * pbegin, pend;
logDebug(target);
logDebug(begin);
logDebug(end);
data_tmp = recvString(target, timeout);
logDebug(data_tmp); // verified
pdata_tmp = strstr (data_tmp, target);
logDebug(pdata_tmp); // verified
// if (data_tmp.indexOf(target) != -1) {
if (NULL != pdata_tmp) {
//logDebug(data_tmp);
pbegin = strstr (data_tmp, begin);
//logDebug(data_tmp);
logDebug(pbegin+strlen(begin)); // it is complete string , to re-verify
pend = strstr (pbegin, end);
//logDebug(data_tmp);
logDebug((pend));
//Serial.println(strlen(pend));
//Serial.println((pend+1));
if( (NULL != pbegin) && (NULL != pend) ) {
// str cat
memset(data, 0, 1);
strncat(data, pbegin+strlen(begin), strlen(pbegin));
return true;
}
//int32_t index1 = data_tmp.indexOf(begin);
//int32_t index2 = data_tmp.indexOf(end);
//if (index1 != -1 && index2 != -1) {
// index1 += begin.length();
// data = data_tmp.substring(index1, index2);
// return true;
//}
}
//data = "";
return false;
}
bool ESP8266::eAT(void)
{
rx_empty();
m_puart->println("AT");
return recvFind("OK");
}
bool ESP8266::eATRST(void)
{
rx_empty();
m_puart->println("AT+RST");
return recvFind("OK");
}
/*
AT+GMR
AT version:1.1.0.0(May 11 2016 18:09:56)
SDK version:1.5.4(baaeaebb)
Ai-Thinker Technology Co. Ltd.
Jun 13 2016 11:29:20
OK
*/
/*
bool ESP8266::eATGMR(String &version)
{
rx_empty();
m_puart->println("AT+GMR");
return recvFindAndFilter("OK", "+GMR", "\r\nOK", version);
//return recvFindAndFilter("OK", "SDK version:", "\r\n\r\nOK", version);
}
*/
bool ESP8266::eATGMR(char * version)
{
rx_empty();
m_puart->println("AT+GMR");
return recvFindAndFilter("OK", "+GMR", "\r\nOK", version);
//return recvFindAndFilter("OK", "SDK version:"/*"\r\r\n"*/, "\r\n\r\nOK", version);
}
bool ESP8266::qATCWMODE(uint8_t *mode)
{
char str_mode[1]={0};
bool ret;
if (!mode) {
//logDebug("not valid");
return false;
}
rx_empty();
m_puart->println("AT+CWMODE?");
ret = recvFindAndFilter("OK", "+CWMODE:", "\r\n\r\nOK", str_mode);
//logDebug(str_mode);
if (ret) {
*mode = (uint8_t)str_mode[0]-0x30;//.toInt();
//logDebug(str_mode[0]);
logDebug(*mode);
return true;
} else {
//logDebug("FALSE");
return false;
}
}
bool ESP8266::sATCWMODE(uint8_t mode)
{
String data;
rx_empty();
m_puart->print("AT+CWMODE=");
m_puart->println(mode);
data = recvString("OK", "no change");
if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCWJAP(String ssid, String pwd)
{
String data;
rx_empty();
m_puart->print("AT+CWJAP=\"");
m_puart->print(ssid);
m_puart->print("\",\"");
m_puart->print(pwd);
m_puart->println("\"");
data = recvString("OK", "FAIL", 10000);
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCWJAP(char * ssid, char * pwd)
{
char * data, *chk;
rx_empty();
m_puart->print("AT+CWJAP=\"");
m_puart->print(ssid);
m_puart->print("\",\"");
m_puart->print(pwd);
m_puart->println("\"");
data = recvString("OK", "FAIL", 10000);
//Serial.println(data);
chk = strstr (data, "OK");
logDebug(chk); //
//if (data.indexOf("OK") != -1) {
if (NULL != chk) {
return true;
}
return false;
}
bool ESP8266::sATCWDHCP(uint8_t mode, boolean enabled)
{
String strEn = "0";
if (enabled) {
strEn = "1";
}
String data;
rx_empty();
m_puart->print("AT+CWDHCP=");
m_puart->print(strEn);
m_puart->print(",");
m_puart->println(mode);
data = recvString("OK", "FAIL", 10000);
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::eATCWLAP(String &list)
{
String data;
rx_empty();
m_puart->println("AT+CWLAP");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
}
bool ESP8266::eATCWQAP(void)
{
String data;
rx_empty();
m_puart->println("AT+CWQAP");
return recvFind("OK");
}
bool ESP8266::sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
String data;
rx_empty();
m_puart->print("AT+CWSAP=\"");
m_puart->print(ssid);
m_puart->print("\",\"");
m_puart->print(pwd);
m_puart->print("\",");
m_puart->print(chl);
m_puart->print(",");
m_puart->println(ecn);
data = recvString("OK", "ERROR", 5000);
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::eATCWLIF(String &list)
{
String data;
rx_empty();
m_puart->println("AT+CWLIF");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::eATCIPSTATUS(String &list)
{
String data;
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*100));
#else
delay(100);
#endif
rx_empty();
m_puart->println("AT+CIPSTATUS");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::sATCIPSTARTSingle(char * type, char * addr, uint32_t port)
{
char * data, chk_ok, chk_alrdycon;
rx_empty();
m_puart->print("AT+CIPSTART=\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
chk_ok = strstr(data, "OK");
chk_alrdycon = strstr(data, "ALREADY CONNECT");
if ( (NULL != chk_ok ) || (NULL != chk_alrdycon) ) {
return true;
}
return false;
}
bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
{
String data;
rx_empty();
m_puart->print("AT+CIPSTART=\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, char * type, char * addr, uint32_t port)
{
char * data, chk_ok, chk_alrdycon;
rx_empty();
m_puart->print("AT+CIPSTART=");
m_puart->print(mux_id);
m_puart->print(",\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
chk_ok = strstr(data, "OK");
chk_alrdycon = strstr(data, "ALREADY CONNECT");
if ( (NULL != chk_ok ) || (NULL != chk_alrdycon) ) {
return true;
}
return false;
}
bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
{
String data;
rx_empty();
m_puart->print("AT+CIPSTART=");
m_puart->print(mux_id);
m_puart->print(",\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
{
rx_empty();
m_puart->print("AT+CIPSEND=");
m_puart->println(len);
if (recvFind(">", 5000)) {
rx_empty();
for (uint32_t i = 0; i < len; i++) {
m_puart->write(buffer[i]);
}
return recvFind("SEND OK", 10000);
}
return false;
}
bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
{
rx_empty();
m_puart->print("AT+CIPSEND=");
m_puart->print(mux_id);
m_puart->print(",");
m_puart->println(len);
if (recvFind(">", 5000)) {
rx_empty();
for (uint32_t i = 0; i < len; i++) {
m_puart->write(buffer[i]);
}
return recvFind("SEND OK", 10000);
}
return false;
}
bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
{
String data;
rx_empty();
m_puart->print("AT+CIPCLOSE=");
m_puart->println(mux_id);
data = recvString("OK", "link is not", 5000);
if (data.indexOf("OK") != -1 || data.indexOf("link is not") != -1) {
return true;
}
return false;
}
bool ESP8266::eATCIPCLOSESingle(void)
{
rx_empty();
m_puart->println("AT+CIPCLOSE");
return recvFind("OK", 5000);
}
bool ESP8266::eATCIFSR(char * list)
{
rx_empty();
m_puart->println("AT+CIFSR");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::sATCIPMUX(uint8_t mode)
{
String data;
rx_empty();
m_puart->print("AT+CIPMUX=");
m_puart->println(mode);
data = recvString("OK", "Link is builded");
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
{
String data;
if (mode) {
rx_empty();
m_puart->print("AT+CIPSERVER=1,");
m_puart->println(port);
data = recvString("OK", "no change");
if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
return true;
}
return false;
} else {
rx_empty();
m_puart->println("AT+CIPSERVER=0");
return recvFind("\r\r\n");
}
}
bool ESP8266::sATCIPSTO(uint32_t timeout)
{
rx_empty();
m_puart->print("AT+CIPSTO=");
m_puart->println(timeout);
return recvFind("OK");
}
ESP8266::recvPkg(...) is being checked
/**
* @file ESP8266.cpp
* @brief The implementation of class ESP8266.
* @author Wu Pengfei<pengfei.wu@itead.cc>
* @date 2015.02
*
* @par Copyright:
* Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version. \n\n
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "ESP8266.h"
#define RTOS_BASED_DELAY
#if defined(RTOS_BASED_DELAY)
#include <Arduino_FreeRTOS.h>
#endif
#define LOG_OUTPUT_DEBUG (0)
#define LOG_OUTPUT_DEBUG_PREFIX (0)
#define logDebug(arg)\
do {\
if (LOG_OUTPUT_DEBUG)\
{\
if (LOG_OUTPUT_DEBUG_PREFIX)\
{\
Serial.print("[LOG Debug: ");\
/*Serial.print((const char*)__FILE__);*/\
/*Serial.print(",");*/\
Serial.print((unsigned int)__LINE__);\
Serial.print(",");\
Serial.print((const char*)__FUNCTION__);\
Serial.print("] ");\
}\
Serial.println(arg);\
}\
} while(0)
#ifdef ESP8266_USE_SOFTWARE_SERIAL
ESP8266::ESP8266(SoftwareSerial &uart, uint32_t baud): m_puart(&uart)
{
m_puart->begin(baud);
rx_empty();
}
#else
ESP8266::ESP8266(HardwareSerial &uart, uint32_t baud): m_puart(&uart)
{
m_puart->begin(baud);
rx_empty();
}
#endif
bool ESP8266::kick(void)
{
return eAT();
}
bool ESP8266::restart(void)
{
//Serial.println("restart");
unsigned long start;
if (eATRST()) {
logDebug(millis());
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*2000));
#else
delay(2000);
#endif
logDebug(millis());
start = millis();
while (millis() - start < 3000) {
if (eAT()) {
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*1500));
#else
delay(1500); /* Waiting for stable */
#endif
return true;
}
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*100));
#else
delay(100);
#endif
}
}
return false;
}
/*
String ESP8266::getVersion(void)
{
String version;
eATGMR(version);
return version;
}
*/
char * ESP8266::getVersion(void)
{
static char version[256] = {0};
memset(version, 0, 256);
eATGMR(version);
return version;
}
bool ESP8266::setOprToStation(void)
{
uint8_t mode;
if (!qATCWMODE(&mode)) {
return false;
}
if (mode == 1) {
return true;
} else {
if (sATCWMODE(1) && restart()) {
return true;
} else {
return false;
}
}
}
bool ESP8266::setOprToSoftAP(void)
{
uint8_t mode;
if (!qATCWMODE(&mode)) {
return false;
}
if (mode == 2) {
return true;
} else {
if (sATCWMODE(2) && restart()) {
return true;
} else {
return false;
}
}
}
bool ESP8266::setOprToStationSoftAP(void)
{
uint8_t mode;
if (!qATCWMODE(&mode)) {
return false;
}
if (mode == 3) {
return true;
} else {
if (sATCWMODE(3) && restart()) {
return true;
} else {
return false;
}
}
}
String ESP8266::getAPList(void)
{
String list;
eATCWLAP(list);
return list;
}
bool ESP8266::joinAP(char * ssid, char * pwd)
{
return sATCWJAP(ssid, pwd);
}
bool ESP8266::enableClientDHCP(uint8_t mode, boolean enabled)
{
return sATCWDHCP(mode, enabled);
}
bool ESP8266::leaveAP(void)
{
return eATCWQAP();
}
bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
return sATCWSAP(ssid, pwd, chl, ecn);
}
String ESP8266::getJoinedDeviceIP(void)
{
String list;
eATCWLIF(list);
return list;
}
String ESP8266::getIPStatus(void)
{
String list;
eATCIPSTATUS(list);
return list;
}
char * ESP8266::getLocalIP(void)
{
static char list[256] = {0};
memset(list, 0, 256);
eATCIFSR(list);
return list;
}
bool ESP8266::enableMUX(void)
{
return sATCIPMUX(1);
}
bool ESP8266::disableMUX(void)
{
return sATCIPMUX(0);
}
bool ESP8266::createTCP(char * addr, uint32_t port)
{
return sATCIPSTARTSingle("TCP", addr, port);
}
//bool ESP8266::createTCP(String addr, uint32_t port)
//{
// return sATCIPSTARTSingle("TCP", addr, port);
//}
bool ESP8266::releaseTCP(void)
{
return eATCIPCLOSESingle();
}
bool ESP8266::registerUDP(String addr, uint32_t port)
{
return sATCIPSTARTSingle("UDP", addr, port);
}
bool ESP8266::unregisterUDP(void)
{
return eATCIPCLOSESingle();
}
bool ESP8266::createTCP(uint8_t mux_id, char * addr, uint32_t port)
{
logDebug(addr);
return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
}
//bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
//{
// logDebug(addr);
// return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
//}
bool ESP8266::releaseTCP(uint8_t mux_id)
{
return sATCIPCLOSEMulitple(mux_id);
}
bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
{
return sATCIPSTARTMultiple(mux_id, "UDP", addr, port);
}
bool ESP8266::unregisterUDP(uint8_t mux_id)
{
return sATCIPCLOSEMulitple(mux_id);
}
bool ESP8266::setTCPServerTimeout(uint32_t timeout)
{
return sATCIPSTO(timeout);
}
bool ESP8266::startTCPServer(uint32_t port)
{
if (sATCIPSERVER(1, port)) {
return true;
}
return false;
}
bool ESP8266::stopTCPServer(void)
{
sATCIPSERVER(0);
restart();
return false;
}
bool ESP8266::startServer(uint32_t port)
{
return startTCPServer(port);
}
bool ESP8266::stopServer(void)
{
return stopTCPServer();
}
bool ESP8266::send(const uint8_t *buffer, uint32_t len)
{
return sATCIPSENDSingle(buffer, len);
}
bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
{
return sATCIPSENDMultiple(mux_id, buffer, len);
}
uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
{
return recvPkg(buffer, buffer_size, NULL, timeout, NULL);
}
uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
{
uint8_t id;
uint32_t ret;
ret = recvPkg(buffer, buffer_size, NULL, timeout, &id);
if (ret > 0 && id == mux_id) {
return ret;
}
return 0;
}
uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
{
return recvPkg(buffer, buffer_size, NULL, timeout, coming_mux_id);
}
/*----------------------------------------------------------------------------*/
/* +IPD,<id>,<len>:<data> */
/* +IPD,<len>:<data> */
/*uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id)
{
String data;
char a;
int32_t index_PIPDcomma = -1;
int32_t index_colon = -1; // : //
int32_t index_comma = -1; // , //
int32_t len = -1;
int8_t id = -1;
bool has_data = false;
uint32_t ret;
unsigned long start;
uint32_t i;
if (buffer == NULL) {
return 0;
}
start = millis();
while (millis() - start < timeout) {
if(m_puart->available() > 0) {
a = m_puart->read();
data += a;
}
index_PIPDcomma = data.indexOf("+IPD,");
if (index_PIPDcomma != -1) {
index_colon = data.indexOf(':', index_PIPDcomma + 5);
if (index_colon != -1) {
index_comma = data.indexOf(',', index_PIPDcomma + 5);
/// +IPD,id,len:data ///
if (index_comma != -1 && index_comma < index_colon) {
id = data.substring(index_PIPDcomma + 5, index_comma).toInt();
if (id < 0 || id > 4) {
return 0;
}
len = data.substring(index_comma + 1, index_colon).toInt();
if (len <= 0) {
return 0;
}
} else { /// +IPD,len:data ///
len = data.substring(index_PIPDcomma + 5, index_colon).toInt();
if (len <= 0) {
return 0;
}
}
has_data = true;
break;
}
}
}
if (has_data) {
i = 0;
ret = len > buffer_size ? buffer_size : len;
start = millis();
while (millis() - start < 3000) {
while(m_puart->available() > 0 && i < ret) {
a = m_puart->read();
buffer[i++] = a;
}
if (i == ret) {
rx_empty();
if (data_len) {
*data_len = len;
}
if (index_comma != -1 && coming_mux_id) {
*coming_mux_id = id;
}
return ret;
}
}
}
return 0;
}*/
uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id)
{
//String data;
static char data[256] = {0};
memset(data,0,256);
static char data2[4] = {0};
memset(data2,0,4);
char a;
int inx = 0;
int32_t index_PIPDcomma = -1;
int32_t index_colon = -1; /* : */
int32_t index_comma = -1; /* , */
int32_t len = -1;
int8_t id = -1;
bool has_data = false;
uint32_t ret;
unsigned long start;
uint32_t i;
if (buffer == NULL) {
return 0;
}
start = millis();
while (millis() - start < timeout) {
Serial.println(__LINE__);
if(m_puart->available() > 0) {
a = m_puart->read();
if(inx<256)
data[inx++] = a;
else
break;
}
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(data);
//pdata1 = strstr (data, target1);
// char *str = "sdfadabcGGGGGGGGG";
//char *result = strstr(str, "abc");
//int position = result - str;
//int substringLength = strlen(str) - position;
// Position of "+IPD,"
index_PIPDcomma = strstr(data, "+IPD,") - data ;//.indexOf("+IPD,");
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(index_PIPDcomma);
if (index_PIPDcomma != -1) {
index_colon = strstr(data+index_PIPDcomma + 5, ":"); // (':', index_PIPDcomma + 5);
//index_colon = data.indexOf(':', index_PIPDcomma + 5);
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(index_colon);
if (index_colon != -1) {
index_comma = strstr(data+index_PIPDcomma + 5, ",");
//index_comma = data.indexOf(',', index_PIPDcomma + 5);
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(index_comma);
/* +IPD,id,len:data */
if (index_comma != -1 && index_comma < index_colon) {
//id = data.substring(index_PIPDcomma + 5, index_comma).toInt();
id = atoi(strncpy(data2, index_PIPDcomma + 5, index_comma));
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(id);
if (id < 0 || id > 4) {
return 0;
}
memset(data2,0,4);
//len = data.substring(index_comma + 1, index_colon).toInt();
len = atoi(strncpy(data2, index_comma + 1, index_colon));
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(len);
if (len <= 0) {
return 0;
}
} else { /* +IPD,len:data */
memset(data2,0,4);
//len = data.substring(index_PIPDcomma + 5, index_colon).toInt();
len = atoi(strncpy(data2, index_PIPDcomma + 5, index_colon));
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(len);
if (len <= 0) {
return 0;
}
}
has_data = true;
break;
}
}
}
if (has_data) {
i = 0;
ret = len > buffer_size ? buffer_size : len;
start = millis();
while (millis() - start < 3000) {
while(m_puart->available() > 0 && i < ret) {
a = m_puart->read();
buffer[i++] = a;
}
if (i == ret) {
rx_empty();
if (data_len) {
*data_len = len;
}
if (index_comma != -1 && coming_mux_id) {
*coming_mux_id = id;
}
return ret;
}
}
}
return 0;
}
void ESP8266::rx_empty(void)
{
while(m_puart->available() > 0) {
m_puart->read();
}
}
String ESP8266::recvString(String target, uint32_t timeout)
{
String data;
char a;
unsigned long start = millis();
//Serial.print("<");
//Serial.print(start);
//Serial.println("< [ ");
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
data += a;
//Serial.write(a);
}
if (data.indexOf(target) != -1) {
break;
}
}
//Serial.print(data);
//Serial.print(" ] <");
//Serial.print(millis());
//Serial.println("<");
return data;
}
char * ESP8266::recvString(char * target, uint32_t timeout)
{
static char data[256] = {0};
memset(data,0,256);
logDebug(target);
int inx=0;
char * pdata1;//* pdata2,* pdata3;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
//data += a;
if(inx<256)
data[inx++] = a;
else
break;
}
pdata1 = strstr (data, target);
logDebug(pdata1);
//pdata2 = strstr (data, target2.c_str());
//pdata3 = strstr (data, target3.c_str());
if (NULL != pdata1) {
break;
} //else if (NULL != pdata2) {
// break;
//} else if (NULL != pdata3) {
// break;
//}
}
logDebug(data);
return data;
}
String ESP8266::recvString(String target1, String target2, uint32_t timeout)
{
String data;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
data += a;
}
if (data.indexOf(target1) != -1) {
break;
} else if (data.indexOf(target2) != -1) {
break;
}
}
return data;
}
char * ESP8266::recvString(char * target1, char * target2, uint32_t timeout)
{
static char data[256] = {0};
memset(data,0,256);
int inx=0;
char * pdata1, * pdata2;//,* pdata3;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
if(inx<256)
data[inx++] = a;
else
break;
}
logDebug(data);
pdata1 = strstr (data, target1);
logDebug(pdata1);
pdata2 = strstr (data, target2);
logDebug(pdata2);
//pdata3 = strstr (data, target3);
//logDebug(pdata1);
if (NULL != pdata1) {
break;
} else if (NULL != pdata2) {
break;
} //else if (NULL != pdata3) {
// break;
//}
}
logDebug(data);
return data;
}
String ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
{
String data;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
data += a;
}
if (data.indexOf(target1) != -1) {
break;
} else if (data.indexOf(target2) != -1) {
break;
} else if (data.indexOf(target3) != -1) {
break;
}
}
return data;
}
char * ESP8266::recvString(char * target1, char * target2, char * target3, uint32_t timeout)
{
static char data[256] = {0};
memset(data,0,256);
int inx=0;
char * pdata1, * pdata2,* pdata3;
char a;
unsigned long start = millis();
while (millis() - start < timeout) {
while(m_puart->available() > 0) {
a = m_puart->read();
if(a == '\0') continue;
if(inx<256)
data[inx++] = a;
else
break;
}
logDebug(data);
pdata1 = strstr (data, target1);
logDebug(pdata1);
pdata2 = strstr (data, target2);
logDebug(pdata2);
pdata3 = strstr (data, target3);
logDebug(pdata3);
if (NULL != pdata1) {
break;
} else if (NULL != pdata2) {
break;
} else if (NULL != pdata3) {
break;
}
}
logDebug(data);
return data;
}
bool ESP8266::recvFind(String target, uint32_t timeout)
{
String data_tmp;
//Serial.println("char?");
//Serial.println(target);
data_tmp = recvString(target, timeout);
if (data_tmp.indexOf(target) != -1) {
return true;
}
return false;
}
bool ESP8266::recvFind(char * target, uint32_t timeout)
{
//char data[256] = {0}; // to be handled
//data = (char*)malloc(256);
char * pdata = NULL;
char * pdata_tmp = NULL;
//Serial.println("char"); // fine
//Serial.println(target); // fine
logDebug(target);
pdata = recvString(target, timeout);
logDebug(pdata);
//Serial.println("char2"); // fine
//Serial.println(pdata); // fine
pdata_tmp = strstr (pdata, target);
logDebug(pdata_tmp);
if (NULL != pdata_tmp) {
return true;
}
return false;
}
bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
{
String data_tmp;
data_tmp = recvString(target, timeout);
if (data_tmp.indexOf(target) != -1) {
int32_t index1 = data_tmp.indexOf(begin);
int32_t index2 = data_tmp.indexOf(end);
if (index1 != -1 && index2 != -1) {
index1 += begin.length();
data = data_tmp.substring(index1, index2);
return true;
}
}
data = "";
return false;
}
bool ESP8266::recvFindAndFilter(char * target, char * begin, char * end, char * data, uint32_t timeout)
{
//String data_tmp;
char * data_tmp;
char * pdata_tmp;
char * pbegin, pend;
logDebug(target);
logDebug(begin);
logDebug(end);
data_tmp = recvString(target, timeout);
logDebug(data_tmp); // verified
pdata_tmp = strstr (data_tmp, target);
logDebug(pdata_tmp); // verified
// if (data_tmp.indexOf(target) != -1) {
if (NULL != pdata_tmp) {
//logDebug(data_tmp);
pbegin = strstr (data_tmp, begin);
//logDebug(data_tmp);
logDebug(pbegin+strlen(begin)); // it is complete string , to re-verify
pend = strstr (pbegin, end);
//logDebug(data_tmp);
logDebug((pend));
//Serial.println(strlen(pend));
//Serial.println((pend+1));
if( (NULL != pbegin) && (NULL != pend) ) {
// str cat
memset(data, 0, 1);
strncat(data, pbegin+strlen(begin), strlen(pbegin));
return true;
}
//int32_t index1 = data_tmp.indexOf(begin);
//int32_t index2 = data_tmp.indexOf(end);
//if (index1 != -1 && index2 != -1) {
// index1 += begin.length();
// data = data_tmp.substring(index1, index2);
// return true;
//}
}
//data = "";
return false;
}
bool ESP8266::eAT(void)
{
rx_empty();
m_puart->println("AT");
return recvFind("OK");
}
bool ESP8266::eATRST(void)
{
rx_empty();
m_puart->println("AT+RST");
return recvFind("OK");
}
/*
AT+GMR
AT version:1.1.0.0(May 11 2016 18:09:56)
SDK version:1.5.4(baaeaebb)
Ai-Thinker Technology Co. Ltd.
Jun 13 2016 11:29:20
OK
*/
/*
bool ESP8266::eATGMR(String &version)
{
rx_empty();
m_puart->println("AT+GMR");
return recvFindAndFilter("OK", "+GMR", "\r\nOK", version);
//return recvFindAndFilter("OK", "SDK version:", "\r\n\r\nOK", version);
}
*/
bool ESP8266::eATGMR(char * version)
{
rx_empty();
m_puart->println("AT+GMR");
return recvFindAndFilter("OK", "+GMR", "\r\nOK", version);
//return recvFindAndFilter("OK", "SDK version:"/*"\r\r\n"*/, "\r\n\r\nOK", version);
}
bool ESP8266::qATCWMODE(uint8_t *mode)
{
char str_mode[1]={0};
bool ret;
if (!mode) {
//logDebug("not valid");
return false;
}
rx_empty();
m_puart->println("AT+CWMODE?");
ret = recvFindAndFilter("OK", "+CWMODE:", "\r\n\r\nOK", str_mode);
//logDebug(str_mode);
if (ret) {
*mode = (uint8_t)str_mode[0]-0x30;//.toInt();
//logDebug(str_mode[0]);
logDebug(*mode);
return true;
} else {
//logDebug("FALSE");
return false;
}
}
bool ESP8266::sATCWMODE(uint8_t mode)
{
String data;
rx_empty();
m_puart->print("AT+CWMODE=");
m_puart->println(mode);
data = recvString("OK", "no change");
if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCWJAP(String ssid, String pwd)
{
String data;
rx_empty();
m_puart->print("AT+CWJAP=\"");
m_puart->print(ssid);
m_puart->print("\",\"");
m_puart->print(pwd);
m_puart->println("\"");
data = recvString("OK", "FAIL", 10000);
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCWJAP(char * ssid, char * pwd)
{
char * data, *chk;
rx_empty();
m_puart->print("AT+CWJAP=\"");
m_puart->print(ssid);
m_puart->print("\",\"");
m_puart->print(pwd);
m_puart->println("\"");
data = recvString("OK", "FAIL", 10000);
//Serial.println(data);
chk = strstr (data, "OK");
logDebug(chk); //
//if (data.indexOf("OK") != -1) {
if (NULL != chk) {
return true;
}
return false;
}
bool ESP8266::sATCWDHCP(uint8_t mode, boolean enabled)
{
String strEn = "0";
if (enabled) {
strEn = "1";
}
String data;
rx_empty();
m_puart->print("AT+CWDHCP=");
m_puart->print(strEn);
m_puart->print(",");
m_puart->println(mode);
data = recvString("OK", "FAIL", 10000);
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::eATCWLAP(String &list)
{
String data;
rx_empty();
m_puart->println("AT+CWLAP");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
}
bool ESP8266::eATCWQAP(void)
{
String data;
rx_empty();
m_puart->println("AT+CWQAP");
return recvFind("OK");
}
bool ESP8266::sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
String data;
rx_empty();
m_puart->print("AT+CWSAP=\"");
m_puart->print(ssid);
m_puart->print("\",\"");
m_puart->print(pwd);
m_puart->print("\",");
m_puart->print(chl);
m_puart->print(",");
m_puart->println(ecn);
data = recvString("OK", "ERROR", 5000);
if (data.indexOf("OK") != -1) {
return true;
}
return false;
}
bool ESP8266::eATCWLIF(String &list)
{
String data;
rx_empty();
m_puart->println("AT+CWLIF");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::eATCIPSTATUS(String &list)
{
String data;
#if defined(RTOS_BASED_DELAY)
vTaskDelay((TickType_t)pdMS_TO_TICKS(2*100));
#else
delay(100);
#endif
rx_empty();
m_puart->println("AT+CIPSTATUS");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::sATCIPSTARTSingle(char * type, char * addr, uint32_t port)
{
char * data, chk_ok, chk_alrdycon;
rx_empty();
m_puart->print("AT+CIPSTART=\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
chk_ok = strstr(data, "OK");
chk_alrdycon = strstr(data, "ALREADY CONNECT");
if ( (NULL != chk_ok ) || (NULL != chk_alrdycon) ) {
return true;
}
return false;
}
bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
{
String data;
rx_empty();
m_puart->print("AT+CIPSTART=\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, char * type, char * addr, uint32_t port)
{
char * data, chk_ok, chk_alrdycon;
rx_empty();
m_puart->print("AT+CIPSTART=");
m_puart->print(mux_id);
m_puart->print(",\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
chk_ok = strstr(data, "OK");
chk_alrdycon = strstr(data, "ALREADY CONNECT");
if ( (NULL != chk_ok ) || (NULL != chk_alrdycon) ) {
return true;
}
return false;
}
bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
{
String data;
rx_empty();
m_puart->print("AT+CIPSTART=");
m_puart->print(mux_id);
m_puart->print(",\"");
m_puart->print(type);
m_puart->print("\",\"");
m_puart->print(addr);
m_puart->print("\",");
m_puart->println(port);
data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
return true;
}
return false;
}
bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
{
rx_empty();
m_puart->print("AT+CIPSEND=");
m_puart->println(len);
if (recvFind(">", 5000)) {
rx_empty();
for (uint32_t i = 0; i < len; i++) {
m_puart->write(buffer[i]);
}
return recvFind("SEND OK", 10000);
}
return false;
}
bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
{
rx_empty();
m_puart->print("AT+CIPSEND=");
m_puart->print(mux_id);
m_puart->print(",");
m_puart->println(len);
if (recvFind(">", 5000)) {
rx_empty();
for (uint32_t i = 0; i < len; i++) {
m_puart->write(buffer[i]);
}
return recvFind("SEND OK", 10000);
}
return false;
}
bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
{
String data;
rx_empty();
m_puart->print("AT+CIPCLOSE=");
m_puart->println(mux_id);
data = recvString("OK", "link is not", 5000);
if (data.indexOf("OK") != -1 || data.indexOf("link is not") != -1) {
return true;
}
return false;
}
bool ESP8266::eATCIPCLOSESingle(void)
{
rx_empty();
m_puart->println("AT+CIPCLOSE");
return recvFind("OK", 5000);
}
bool ESP8266::eATCIFSR(char * list)
{
rx_empty();
m_puart->println("AT+CIFSR");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::sATCIPMUX(uint8_t mode)
{
char * data = NULL;
rx_empty();
m_puart->print("AT+CIPMUX=");
m_puart->println(mode);
data = recvString("OK", "Link is builded");
//Serial.println(data);
if ((NULL != data) ) {
return true;
}
return false;
}
bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
{
char *data = NULL;
char *ok = NULL;
char *nc = NULL ;
if (mode) {
rx_empty();
m_puart->print("AT+CIPSERVER=1,");
m_puart->println(port);
data = recvString("OK", "no change");
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(data);
ok = strstr (data, "OK");
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(ok);
nc = strstr (data, "no change");
Serial.print(__LINE__);
Serial.print(" ");
Serial.println(nc);
if( (NULL != ok) || (NULL != nc) ) {
return true;
}
return false;
} else {
rx_empty();
m_puart->println("AT+CIPSERVER=0");
return recvFind("\r\r\n");
}
}
bool ESP8266::sATCIPSTO(uint32_t timeout)
{
rx_empty();
m_puart->print("AT+CIPSTO=");
m_puart->println(timeout);
return recvFind("OK");
}
|
/* This file is part of the Tomographer project, which is distributed under the
* terms of the MIT license.
*
* The MIT License (MIT)
*
* Copyright (c) 2016 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <cstdio>
#include <cstring>
#include <ctime>
#include <unistd.h>
#include <signal.h>
#include <random>
#include <map>
#include <chrono>
#include <algorithm>
#include <string>
#include <functional>
#include <boost/math/constants/constants.hpp>
// definitions for Tomographer test framework -- this must be included before any
// <Eigen/...> or <tomographer2/...> header
#include "test_tomographer.h"
#include <tomographer2/multiprocomp.h>
#include <tomographer2/tools/loggers.h>
#include <tomographer2/mhrwtasks.h>
#include <tomographer2/densedm/dmtypes.h>
#include <tomographer2/densedm/indepmeasllh.h>
#include <tomographer2/densedm/tspacefigofmerit.h>
#include <tomographer2/densedm/tspacellhwalker.h>
#include <tomographer2/tools/boost_test_logger.h>
#include "test_multi_tasks_common.h"
// -----------------------------------------------------------------------------
// fixtures:
#ifndef __MINGW32__
// MinGW32 does not have SIGALRM / alarm()
std::function<void()> sigalarm_act;
void sigalarm_act_cfn(int signum)
{
printf("[SIGALRM]\n");
if (signum == SIGALRM) {
sigalarm_act();
}
}
#endif
// -----------------------------------------------------------------------------
// test cases:
BOOST_AUTO_TEST_SUITE(test_multiprocomp)
// =============================================================================
BOOST_AUTO_TEST_SUITE(OMPThreadSanitizerLogger)
BOOST_AUTO_TEST_CASE(relays_logs)
{
Tomographer::Logger::BufferLogger buflog(Tomographer::Logger::DEBUG);
Tomographer::MultiProc::OMP::ThreadSanitizerLogger<Tomographer::Logger::BufferLogger> testtasklogger(buflog);
testtasklogger.longdebug("origin", "longdebug level");
testtasklogger.debug("origin", "debug level");
testtasklogger.info("origin", "info level");
testtasklogger.warning("origin", "warning level");
testtasklogger.error("origin", "error level");
BOOST_CHECK_EQUAL(
buflog.getContents(),
"[origin] debug level\n"
"[origin] info level\n"
"[origin] warning level\n"
"[origin] error level\n"
);
}
BOOST_AUTO_TEST_CASE(fixes_level)
{
Tomographer::Logger::BufferLogger buflog(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::ThreadSanitizerLogger<Tomographer::Logger::BufferLogger> testtasklogger(buflog);
// this should NOT have any effect for testtasklogger, because OMP::ThreadSanitizerLogger
// should fix the level at construction time for thread-safety/consistency reasons.
buflog.setLevel(Tomographer::Logger::WARNING);
testtasklogger.longdebug("origin", "test message");
BOOST_CHECK_EQUAL(buflog.getContents(), "[origin] test message\n");
}
BOOST_AUTO_TEST_CASE(parallel)
{
//
// Make sure that the output of the log is not mangled. We sort the lines because of
// course the order is undefined, but each line should be intact (thanks to
// OMP::ThreadSanitizerLogger's wrapping into "#pragma omp critical" sections).
//
Tomographer::Logger::BufferLogger buflog(Tomographer::Logger::LONGDEBUG);
#pragma omp parallel shared(buflog)
{
Tomographer::MultiProc::OMP::ThreadSanitizerLogger<Tomographer::Logger::BufferLogger> testtasklogger(buflog);
testtasklogger.longdebug("main()", "test task logger from core #%06d of %06d",
omp_get_thread_num(), omp_get_num_threads());
}
std::string buflog_str = buflog.getContents();
BOOST_MESSAGE("buflog contents: \n" << buflog_str);
BOOST_CHECK(buflog_str.size());
std::vector<std::string> lines;
std::stringstream ss(buflog_str);
std::string line;
while (std::getline(ss, line, '\n')) {
lines.push_back(line);
}
std::sort(lines.begin(), lines.end()); // std::string's operator< does lexicographical comparision
std::ostringstream sorted_stream;
std::copy(lines.begin(), lines.end(), std::ostream_iterator<std::string>(sorted_stream, "\n"));
std::string sorted = sorted_stream.str();
std::string reference_str;
for (int k = 0; k < (int)lines.size(); ++k) {
reference_str += Tomographer::Tools::fmts("[main()] test task logger from core #%06d of %06d\n",
k, (int)lines.size());
}
BOOST_CHECK_EQUAL(sorted, reference_str);
}
BOOST_AUTO_TEST_SUITE_END();
// -----------------------------------------------------------------------------
BOOST_AUTO_TEST_SUITE(t__MultiProc__OMP__TaskDispatcher);
BOOST_FIXTURE_TEST_CASE(tasks_run, test_task_dispatcher_fixture)
{
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<TestTask, TestBasicCData, TestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
BOOST_MESSAGE("About to run tasks");
task_dispatcher.run();
BOOST_CHECK_EQUAL(resultsCollector.init_called, 1);
BOOST_CHECK_EQUAL(resultsCollector.collectres_called, num_runs);
BOOST_CHECK_EQUAL(resultsCollector.runsfinished_called, 1);
}
BOOST_FIXTURE_TEST_CASE(make_task_dispatcher, test_task_dispatcher_fixture)
{
typedef Tomographer::MultiProc::OMP::TaskDispatcher<TestTask, TestBasicCData, TestResultsCollector,
Tomographer::Logger::BoostTestLogger, int> TaskDispatcherType;
Tomographer::Logger::BoostTestLogger logger;
auto task_dispatcher = Tomographer::MultiProc::OMP::makeTaskDispatcher<TestTask>(
&cData, &resultsCollector, logger,
num_runs, 1);
// just check that the type was properly deduced (including all template parameters)
BOOST_CHECK_EQUAL(std::string(typeid(task_dispatcher).name()),
std::string(typeid(TaskDispatcherType).name()));
}
struct TestTaskCheckAlignedStack : public TestTask {
template<typename... Args>
TestTaskCheckAlignedStack(Args&&... x)
: TestTask(std::forward<Args>(x)...)
{ }
template<typename LoggerType, typename TaskManagerIface>
void run(const TestBasicCData * pcdata, LoggerType & logger, TaskManagerIface * iface)
{
char blah_data[5] = {0}; // some random stuff -- not really needed, it's just here to clutter the code and memory
// make sure that the stack is aligned
Eigen::Matrix4d m;
BOOST_MESSAGE( "m.data() == " << (uintptr_t)m.data() );
BOOST_CHECK( (((uintptr_t)m.data()) & 0xf) == 0 ); // pointer to matrix data is aligned to multiple of 16 bytes
// and run the parent task
TestTask::run(pcdata, logger, iface);
(void)blah_data;
}
};
BOOST_FIXTURE_TEST_CASE(inner_code_stack_aligned, test_task_dispatcher_fixture)
{
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::DEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<TestTaskCheckAlignedStack, TestBasicCData,
TestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
char blah_data[4] = {0}; // some random stuff -- not really needed, it's just here to clutter the code and memory
char blah_data2[7] = {0}; // some random stuff -- not really needed, it's just here to clutter the code and memory
task_dispatcher.run();
(void)blah_data;
(void)blah_data2;
}
struct StatusRepTestBasicCData {
StatusRepTestBasicCData() { }
int getTaskInput(int k) const {
return (k == 0);
}
};
struct StatusRepTestTask {
typedef Tomographer::MultiProc::TaskStatusReport StatusReportType;
typedef bool ResultType;
template<typename LoggerType>
StatusRepTestTask(int input, const StatusRepTestBasicCData * , LoggerType & )
: _input(input)
{
}
template<typename LoggerType, typename TaskManagerIface>
void run(const StatusRepTestBasicCData * , LoggerType & logger, TaskManagerIface * iface)
{
_result = false;
// Check for status reports, and generate one once requested. Run the task
// like this for five seconds.
unsigned long count = 0;
std::time_t time_start;
std::time(&time_start);
std::time_t now = time_start;
int elapsed = 0;
do {
std::time(&now);
elapsed = now - time_start;
if (iface->statusReportRequested()) {
logger.longdebug("StatusRepTestTask::run", "Task #%02d: Status report requested", _input);
StatusReportType s(elapsed / 5.0,
Tomographer::Tools::fmts("elapsed = %d [%.2f%%]; count = %lu = %#lx",
elapsed, 100*elapsed/5.0, count, count));
logger.longdebug("StatusRepTestTask::run", "s.msg = %s", s.msg.c_str());
iface->submitStatusReport(s);
logger.longdebug("StatusRepTestTask::run", "report submitted.");
_result = true;
}
++count;
if ((count & 0xffff) == 0) {
logger.longdebug("StatusRepTestTask::run", "count = %lu", count);
}
} while (now - time_start < 5);
}
ResultType getResult() const { return _result; }
private:
int _input;
ResultType _result;
};
struct StatusRepTestResultsCollector {
StatusRepTestResultsCollector()
{
}
void init(int, int, const StatusRepTestBasicCData * )
{
}
template<typename ResultType>
void collectResult(int, const ResultType& taskresult, const StatusRepTestBasicCData *)
{
BOOST_CHECK_EQUAL(taskresult, true);
}
void runsFinished(int, const StatusRepTestBasicCData * )
{
}
};
#ifdef _OPENMP
BOOST_AUTO_TEST_CASE(status_report_withthread)
{
StatusRepTestBasicCData cData;
const int num_runs = 10;
StatusRepTestResultsCollector resultsCollector;
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<StatusRepTestTask, StatusRepTestBasicCData,
StatusRepTestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
task_dispatcher.setStatusReportHandler(
[&logger](const Tomographer::MultiProc::FullStatusReport<StatusRepTestTask::StatusReportType>& r) {
logger.info("status_report test case", [&](std::ostream & stream) {
stream << "Full status report recieved. num_completed = " << r.num_completed
<< ", num_total_runs = " << r.num_total_runs << "\n";
for (std::size_t k = 0; k < r.workers_running.size(); ++k) {
if (!r.workers_running[k]) {
stream << "Worker #" << k << " idle\n";
} else {
stream << "Worker #" << k << ": " << r.workers_reports[k].fraction_done * 100 << "%, "
<< r.workers_reports[k].msg << "\n";
}
}
});
});
omp_set_dynamic(0);
omp_set_nested(1);
volatile std::sig_atomic_t finished = 0;
#pragma omp parallel num_threads(2)
{
if (omp_get_thread_num() == 0) {
// take care of sending status report requests
while (!finished) {
sleep(1);
task_dispatcher.requestStatusReport();
}
} else if (omp_get_thread_num() == 1) {
// run the slave tasks
task_dispatcher.run();
finished = 1;
} else {
// never here
assert( false ) ;
}
}
logger.debug("test case:status_report", "Test case done.");
}
#endif
//
// Also provide some testing for non-OpenMP enabled platforms:
//
#ifndef __MINGW32__
// MinGW32 does not have SIGALRM / alarm()
BOOST_AUTO_TEST_CASE(status_report_withsigalrm)
{
StatusRepTestBasicCData cData;
const int num_runs = 10;
StatusRepTestResultsCollector resultsCollector;
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<StatusRepTestTask, StatusRepTestBasicCData,
StatusRepTestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
task_dispatcher.setStatusReportHandler(
[&logger](const Tomographer::MultiProc::FullStatusReport<StatusRepTestTask::StatusReportType>& r) {
logger.info("status_report test case", [&](std::ostream & stream) {
stream << "Full status report recieved. num_completed = " << r.num_completed
<< ", num_total_runs = " << r.num_total_runs << "\n";
for (std::size_t k = 0; k < r.workers_running.size(); ++k) {
if (!r.workers_running[k]) {
stream << "Worker #" << k << " idle\n";
} else {
stream << "Worker #" << k << ": " << r.workers_reports[k].fraction_done * 100 << "%, "
<< r.workers_reports[k].msg << "\n";
}
}
});
});
{
auto finally = Tomographer::Tools::finally([](){
alarm(0);
signal(SIGALRM, SIG_DFL);
});
sigalarm_act = [&task_dispatcher]() {
task_dispatcher.requestStatusReport();
alarm(2);
signal(SIGALRM, sigalarm_act_cfn);
};
alarm(1);
signal(SIGALRM, sigalarm_act_cfn);
task_dispatcher.run();
}
}
#endif
#if !defined(_OPENMP) && defined(__MINGW__)
BOOST_AUTO_TEST_CASE(status_report_not_implemented)
{
BOOST_CHECK(false && "Status report check NOT IMPLEMENTED on your platform, sorry");
}
#endif
BOOST_AUTO_TEST_SUITE_END();
// =============================================================================
BOOST_AUTO_TEST_SUITE_END();
commented out unreliable status report testing in test_multiprocomp
/* This file is part of the Tomographer project, which is distributed under the
* terms of the MIT license.
*
* The MIT License (MIT)
*
* Copyright (c) 2016 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <cstdio>
#include <cstring>
#include <ctime>
#include <unistd.h>
#include <signal.h>
#include <random>
#include <map>
#include <chrono>
#include <algorithm>
#include <string>
#include <functional>
#include <boost/math/constants/constants.hpp>
// definitions for Tomographer test framework -- this must be included before any
// <Eigen/...> or <tomographer2/...> header
#include "test_tomographer.h"
#include <tomographer2/multiprocomp.h>
#include <tomographer2/tools/loggers.h>
#include <tomographer2/mhrwtasks.h>
#include <tomographer2/densedm/dmtypes.h>
#include <tomographer2/densedm/indepmeasllh.h>
#include <tomographer2/densedm/tspacefigofmerit.h>
#include <tomographer2/densedm/tspacellhwalker.h>
#include <tomographer2/tools/boost_test_logger.h>
#include "test_multi_tasks_common.h"
// -----------------------------------------------------------------------------
// fixtures:
#ifndef __MINGW32__
// MinGW32 does not have SIGALRM / alarm()
std::function<void()> sigalarm_act;
void sigalarm_act_cfn(int signum)
{
printf("[SIGALRM]\n");
if (signum == SIGALRM) {
sigalarm_act();
}
}
#endif
// -----------------------------------------------------------------------------
// test cases:
BOOST_AUTO_TEST_SUITE(test_multiprocomp)
// =============================================================================
BOOST_AUTO_TEST_SUITE(OMPThreadSanitizerLogger)
BOOST_AUTO_TEST_CASE(relays_logs)
{
Tomographer::Logger::BufferLogger buflog(Tomographer::Logger::DEBUG);
Tomographer::MultiProc::OMP::ThreadSanitizerLogger<Tomographer::Logger::BufferLogger> testtasklogger(buflog);
testtasklogger.longdebug("origin", "longdebug level");
testtasklogger.debug("origin", "debug level");
testtasklogger.info("origin", "info level");
testtasklogger.warning("origin", "warning level");
testtasklogger.error("origin", "error level");
BOOST_CHECK_EQUAL(
buflog.getContents(),
"[origin] debug level\n"
"[origin] info level\n"
"[origin] warning level\n"
"[origin] error level\n"
);
}
BOOST_AUTO_TEST_CASE(fixes_level)
{
Tomographer::Logger::BufferLogger buflog(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::ThreadSanitizerLogger<Tomographer::Logger::BufferLogger> testtasklogger(buflog);
// this should NOT have any effect for testtasklogger, because OMP::ThreadSanitizerLogger
// should fix the level at construction time for thread-safety/consistency reasons.
buflog.setLevel(Tomographer::Logger::WARNING);
testtasklogger.longdebug("origin", "test message");
BOOST_CHECK_EQUAL(buflog.getContents(), "[origin] test message\n");
}
BOOST_AUTO_TEST_CASE(parallel)
{
//
// Make sure that the output of the log is not mangled. We sort the lines because of
// course the order is undefined, but each line should be intact (thanks to
// OMP::ThreadSanitizerLogger's wrapping into "#pragma omp critical" sections).
//
Tomographer::Logger::BufferLogger buflog(Tomographer::Logger::LONGDEBUG);
#pragma omp parallel shared(buflog)
{
Tomographer::MultiProc::OMP::ThreadSanitizerLogger<Tomographer::Logger::BufferLogger> testtasklogger(buflog);
testtasklogger.longdebug("main()", "test task logger from core #%06d of %06d",
omp_get_thread_num(), omp_get_num_threads());
}
std::string buflog_str = buflog.getContents();
BOOST_MESSAGE("buflog contents: \n" << buflog_str);
BOOST_CHECK(buflog_str.size());
std::vector<std::string> lines;
std::stringstream ss(buflog_str);
std::string line;
while (std::getline(ss, line, '\n')) {
lines.push_back(line);
}
std::sort(lines.begin(), lines.end()); // std::string's operator< does lexicographical comparision
std::ostringstream sorted_stream;
std::copy(lines.begin(), lines.end(), std::ostream_iterator<std::string>(sorted_stream, "\n"));
std::string sorted = sorted_stream.str();
std::string reference_str;
for (int k = 0; k < (int)lines.size(); ++k) {
reference_str += Tomographer::Tools::fmts("[main()] test task logger from core #%06d of %06d\n",
k, (int)lines.size());
}
BOOST_CHECK_EQUAL(sorted, reference_str);
}
BOOST_AUTO_TEST_SUITE_END();
// -----------------------------------------------------------------------------
BOOST_AUTO_TEST_SUITE(t__MultiProc__OMP__TaskDispatcher);
BOOST_FIXTURE_TEST_CASE(tasks_run, test_task_dispatcher_fixture)
{
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<TestTask, TestBasicCData, TestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
BOOST_MESSAGE("About to run tasks");
task_dispatcher.run();
BOOST_CHECK_EQUAL(resultsCollector.init_called, 1);
BOOST_CHECK_EQUAL(resultsCollector.collectres_called, num_runs);
BOOST_CHECK_EQUAL(resultsCollector.runsfinished_called, 1);
}
BOOST_FIXTURE_TEST_CASE(make_task_dispatcher, test_task_dispatcher_fixture)
{
typedef Tomographer::MultiProc::OMP::TaskDispatcher<TestTask, TestBasicCData, TestResultsCollector,
Tomographer::Logger::BoostTestLogger, int> TaskDispatcherType;
Tomographer::Logger::BoostTestLogger logger;
auto task_dispatcher = Tomographer::MultiProc::OMP::makeTaskDispatcher<TestTask>(
&cData, &resultsCollector, logger,
num_runs, 1);
// just check that the type was properly deduced (including all template parameters)
BOOST_CHECK_EQUAL(std::string(typeid(task_dispatcher).name()),
std::string(typeid(TaskDispatcherType).name()));
}
struct TestTaskCheckAlignedStack : public TestTask {
template<typename... Args>
TestTaskCheckAlignedStack(Args&&... x)
: TestTask(std::forward<Args>(x)...)
{ }
template<typename LoggerType, typename TaskManagerIface>
void run(const TestBasicCData * pcdata, LoggerType & logger, TaskManagerIface * iface)
{
char blah_data[5] = {0}; // some random stuff -- not really needed, it's just here to clutter the code and memory
// make sure that the stack is aligned
Eigen::Matrix4d m;
BOOST_MESSAGE( "m.data() == " << (uintptr_t)m.data() );
BOOST_CHECK( (((uintptr_t)m.data()) & 0xf) == 0 ); // pointer to matrix data is aligned to multiple of 16 bytes
// and run the parent task
TestTask::run(pcdata, logger, iface);
(void)blah_data;
}
};
BOOST_FIXTURE_TEST_CASE(inner_code_stack_aligned, test_task_dispatcher_fixture)
{
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::DEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<TestTaskCheckAlignedStack, TestBasicCData,
TestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
char blah_data[4] = {0}; // some random stuff -- not really needed, it's just here to clutter the code and memory
char blah_data2[7] = {0}; // some random stuff -- not really needed, it's just here to clutter the code and memory
task_dispatcher.run();
(void)blah_data;
(void)blah_data2;
}
/*
// THESE TESTS ARE NOT RELIABLE ... not sure why
struct StatusRepTestBasicCData {
StatusRepTestBasicCData() { }
int getTaskInput(int k) const {
return (k == 0);
}
};
struct StatusRepTestTask {
typedef Tomographer::MultiProc::TaskStatusReport StatusReportType;
typedef bool ResultType;
template<typename LoggerType>
StatusRepTestTask(int input, const StatusRepTestBasicCData * , LoggerType & )
: _input(input)
{
}
template<typename LoggerType, typename TaskManagerIface>
void run(const StatusRepTestBasicCData * , LoggerType & logger, TaskManagerIface * iface)
{
_result = false;
// Check for status reports, and generate one once requested. Run the task
// like this for five seconds.
unsigned long count = 0;
std::time_t time_start;
std::time(&time_start);
std::time_t now = time_start;
int elapsed = 0;
do {
std::time(&now);
elapsed = now - time_start;
if (iface->statusReportRequested()) {
logger.longdebug("StatusRepTestTask::run", "Task #%02d: Status report requested", _input);
StatusReportType s(elapsed / 5.0,
Tomographer::Tools::fmts("elapsed = %d [%.2f%%]; count = %lu = %#lx",
elapsed, 100*elapsed/5.0, count, count));
logger.longdebug("StatusRepTestTask::run", "s.msg = %s", s.msg.c_str());
iface->submitStatusReport(s);
logger.longdebug("StatusRepTestTask::run", "report submitted.");
_result = true;
}
++count;
if ((count & 0xffff) == 0) {
logger.longdebug("StatusRepTestTask::run", "count = %lu", count);
}
} while (now - time_start < 5);
}
ResultType getResult() const { return _result; }
private:
int _input;
ResultType _result;
};
struct StatusRepTestResultsCollector {
StatusRepTestResultsCollector()
{
}
void init(int, int, const StatusRepTestBasicCData * )
{
}
template<typename ResultType>
void collectResult(int, const ResultType& taskresult, const StatusRepTestBasicCData *)
{
BOOST_CHECK_EQUAL(taskresult, true);
}
void runsFinished(int, const StatusRepTestBasicCData * )
{
}
};
#ifdef _OPENMP
BOOST_AUTO_TEST_CASE(status_report_withthread)
{
StatusRepTestBasicCData cData;
const int num_runs = 10;
StatusRepTestResultsCollector resultsCollector;
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<StatusRepTestTask, StatusRepTestBasicCData,
StatusRepTestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
task_dispatcher.setStatusReportHandler(
[&logger](const Tomographer::MultiProc::FullStatusReport<StatusRepTestTask::StatusReportType>& r) {
logger.info("status_report test case", [&](std::ostream & stream) {
stream << "Full status report recieved. num_completed = " << r.num_completed
<< ", num_total_runs = " << r.num_total_runs << "\n";
for (std::size_t k = 0; k < r.workers_running.size(); ++k) {
if (!r.workers_running[k]) {
stream << "Worker #" << k << " idle\n";
} else {
stream << "Worker #" << k << ": " << r.workers_reports[k].fraction_done * 100 << "%, "
<< r.workers_reports[k].msg << "\n";
}
}
});
});
omp_set_dynamic(0);
omp_set_nested(1);
volatile std::sig_atomic_t finished = 0;
#pragma omp parallel num_threads(2)
{
if (omp_get_thread_num() == 0) {
// take care of sending status report requests
while (!finished) {
sleep(1);
task_dispatcher.requestStatusReport();
}
} else if (omp_get_thread_num() == 1) {
// run the slave tasks
task_dispatcher.run();
finished = 1;
} else {
// never here
assert( false ) ;
}
}
logger.debug("test case:status_report", "Test case done.");
}
#endif
//
// Also provide some testing for non-OpenMP enabled platforms:
//
#ifndef __MINGW32__
// MinGW32 does not have SIGALRM / alarm()
BOOST_AUTO_TEST_CASE(status_report_withsigalrm)
{
StatusRepTestBasicCData cData;
const int num_runs = 10;
StatusRepTestResultsCollector resultsCollector;
Tomographer::Logger::BoostTestLogger logger(Tomographer::Logger::LONGDEBUG);
Tomographer::MultiProc::OMP::TaskDispatcher<StatusRepTestTask, StatusRepTestBasicCData,
StatusRepTestResultsCollector,
Tomographer::Logger::BoostTestLogger, long>
task_dispatcher(&cData, &resultsCollector, logger, num_runs, 1);
task_dispatcher.setStatusReportHandler(
[&logger](const Tomographer::MultiProc::FullStatusReport<StatusRepTestTask::StatusReportType>& r) {
logger.info("status_report test case", [&](std::ostream & stream) {
stream << "Full status report recieved. num_completed = " << r.num_completed
<< ", num_total_runs = " << r.num_total_runs << "\n";
for (std::size_t k = 0; k < r.workers_running.size(); ++k) {
if (!r.workers_running[k]) {
stream << "Worker #" << k << " idle\n";
} else {
stream << "Worker #" << k << ": " << r.workers_reports[k].fraction_done * 100 << "%, "
<< r.workers_reports[k].msg << "\n";
}
}
});
});
{
auto finally = Tomographer::Tools::finally([](){
alarm(0);
signal(SIGALRM, SIG_DFL);
});
sigalarm_act = [&task_dispatcher]() {
task_dispatcher.requestStatusReport();
alarm(2);
signal(SIGALRM, sigalarm_act_cfn);
};
alarm(1);
signal(SIGALRM, sigalarm_act_cfn);
task_dispatcher.run();
}
}
#endif
#if !defined(_OPENMP) && defined(__MINGW__)
BOOST_AUTO_TEST_CASE(status_report_not_implemented)
{
BOOST_CHECK(false && "Status report check NOT IMPLEMENTED on your platform, sorry");
}
#endif
*/
BOOST_AUTO_TEST_SUITE_END();
// =============================================================================
BOOST_AUTO_TEST_SUITE_END();
|
/*
* Copyright (C) 2009 Marc Boris Duerner, Tommi Maekitalo
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* As a special exception, you may use this file as part of a free
* software library without restriction. Specifically, if other files
* instantiate templates or use macros or inline functions from this
* file, or you compile this file and link it with other files to
* produce an executable, this file does not by itself cause the
* resulting executable to be covered by the GNU General Public
* License. This exception does not however invalidate any other
* reasons why the executable file might be covered by the GNU Library
* General Public License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#ifdef HAVE_ACCEPT4
#include <sys/types.h>
#include <sys/socket.h>
#endif
#include "tcpsocketimpl.h"
#include "tcpserverimpl.h"
#include "cxxtools/net/tcpserver.h"
#include "cxxtools/net/tcpsocket.h"
#include "cxxtools/systemerror.h"
#include "cxxtools/ioerror.h"
#include "cxxtools/log.h"
#include "config.h"
#include "error.h"
#include <cerrno>
#include <cstring>
#include <cassert>
#include <fcntl.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
log_define("cxxtools.net.tcpsocket.impl")
namespace cxxtools
{
namespace net
{
void formatIp(const sockaddr_storage& addr, std::string& str)
{
#ifdef HAVE_INET_NTOP
const sockaddr_in* sa = reinterpret_cast<const sockaddr_in*>(&addr);
char strbuf[INET6_ADDRSTRLEN + 1];
const char* p = inet_ntop(sa->sin_family, &sa->sin_addr, strbuf, sizeof(strbuf));
str = (p == 0 ? "-" : strbuf);
#else
static cxxtools::Mutex monitor;
cxxtools::MutexLock lock(monitor);
const sockaddr_in* sa = reinterpret_cast<const sockaddr_in*>(&addr);
const char* p = inet_ntoa(sa->sin_addr);
if (p)
str = p;
else
str.clear();
#endif
}
TcpSocketImpl::TcpSocketImpl(TcpSocket& socket)
: IODeviceImpl(socket)
, _socket(socket)
, _isConnected(false)
{
}
TcpSocketImpl::~TcpSocketImpl()
{
assert(_pfd == 0);
}
void TcpSocketImpl::close()
{
log_debug("close socket " << _fd);
IODeviceImpl::close();
_isConnected = false;
}
std::string TcpSocketImpl::getSockAddr() const
{
struct sockaddr_storage addr;
socklen_t slen = sizeof(addr);
if (::getsockname(fd(), reinterpret_cast<struct sockaddr*>(&addr), &slen) < 0)
throw SystemError("getsockname");
std::string ret;
formatIp(addr, ret);
return ret;
}
std::string TcpSocketImpl::getPeerAddr() const
{
std::string ret;
formatIp(_peeraddr, ret);
return ret;
}
void TcpSocketImpl::connect(const AddrInfo& addrInfo)
{
log_debug("connect");
this->beginConnect(addrInfo);
this->endConnect();
}
int TcpSocketImpl::checkConnect()
{
log_trace("checkConnect");
int sockerr;
socklen_t optlen = sizeof(sockerr);
// check for socket error
if( ::getsockopt(this->fd(), SOL_SOCKET, SO_ERROR, &sockerr, &optlen) != 0 )
{
// getsockopt failed
int e = errno;
close();
throw SystemError(e, "getsockopt");
}
if (sockerr == 0)
{
log_debug("connected successfully to " << getPeerAddr());
_isConnected = true;
}
return sockerr;
}
void TcpSocketImpl::checkPendingError()
{
if (_connectResult.second)
{
std::pair<int, const char*> p = _connectResult;
_connectResult = std::pair<int, const char*>(0, 0);
if (p.first)
{
throw IOError(getErrnoString(p.first, p.second).c_str());
}
else
{
throw IOError("invalid address information");
}
}
}
std::pair<int, const char*> TcpSocketImpl::tryConnect()
{
log_trace("tryConnect");
assert(_fd == -1);
if (_addrInfoPtr == _addrInfo.impl()->end())
{
log_debug("no more address informations");
return std::pair<int, const char*>(0, "invalid address information");
}
while (true)
{
int fd;
while (true)
{
log_debug("create socket");
fd = ::socket(_addrInfoPtr->ai_family, SOCK_STREAM, 0);
if (fd >= 0)
break;
if (++_addrInfoPtr == _addrInfo.impl()->end())
return std::pair<int, const char*>(errno, "socket");
}
IODeviceImpl::open(fd, true, false);
std::memmove(&_peeraddr, _addrInfoPtr->ai_addr, _addrInfoPtr->ai_addrlen);
log_debug("created socket " << _fd << " max: " << FD_SETSIZE);
if( ::connect(this->fd(), _addrInfoPtr->ai_addr, _addrInfoPtr->ai_addrlen) == 0 )
{
_isConnected = true;
log_debug("connected successfully to " << getPeerAddr());
break;
}
if (errno == EINPROGRESS)
{
log_debug("connect in progress");
break;
}
close();
if (++_addrInfoPtr == _addrInfo.impl()->end())
return std::pair<int, const char*>(errno, "connect");
}
return std::pair<int, const char*>(0, 0);
}
bool TcpSocketImpl::beginConnect(const AddrInfo& addrInfo)
{
log_trace("begin connect");
assert(!_isConnected);
_addrInfo = addrInfo;
_addrInfoPtr = _addrInfo.impl()->begin();
_connectResult = tryConnect();
checkPendingError();
return _isConnected;
}
void TcpSocketImpl::endConnect()
{
log_trace("ending connect");
if(_pfd && ! _socket.wbuf())
{
_pfd->events &= ~POLLOUT;
}
checkPendingError();
if( _isConnected )
return;
try
{
while (true)
{
pollfd pfd;
pfd.fd = this->fd();
pfd.revents = 0;
pfd.events = POLLOUT;
log_debug("wait " << timeout() << " ms");
bool avail = this->wait(this->timeout(), pfd);
if (avail)
{
// something has happened
int sockerr = checkConnect();
if (_isConnected)
return;
if (++_addrInfoPtr == _addrInfo.impl()->end())
{
// no more addrInfo - propagate error
throw IOError(getErrnoString(sockerr, "connect").c_str());
}
}
else if (++_addrInfoPtr == _addrInfo.impl()->end())
{
log_debug("timeout");
throw IOTimeout();
}
close();
_connectResult = tryConnect();
if (_isConnected)
return;
checkPendingError();
}
}
catch(...)
{
close();
throw;
}
}
void TcpSocketImpl::accept(const TcpServer& server, unsigned flags)
{
socklen_t peeraddr_len = sizeof(_peeraddr);
_fd = server.impl().accept(flags, reinterpret_cast <struct sockaddr*>(&_peeraddr), peeraddr_len);
if( _fd < 0 )
throw SystemError("accept");
#ifdef HAVE_ACCEPT4
IODeviceImpl::open(_fd, false, false);
#else
IODeviceImpl::open(_fd, true, inherit);
#endif
//TODO ECONNABORTED EINTR EPERM
_isConnected = true;
log_debug( "accepted from " << getPeerAddr());
}
void TcpSocketImpl::initWait(pollfd& pfd)
{
IODeviceImpl::initWait(pfd);
if( ! _isConnected )
{
log_debug("not connected, setting POLLOUT ");
pfd.events = POLLOUT;
}
}
bool TcpSocketImpl::checkPollEvent(pollfd& pfd)
{
log_debug("checkPollEvent " << pfd.revents);
if( _isConnected )
return IODeviceImpl::checkPollEvent(pfd);
if ( pfd.revents & POLLERR )
{
AddrInfoImpl::const_iterator ptr = _addrInfoPtr;
if (++ptr == _addrInfo.impl()->end())
{
// not really connected but error
// end of addrinfo list means that no working addrinfo was found
log_debug("no more addrinfos found");
_socket.connected.send(_socket);
return true;
}
else
{
_addrInfoPtr = ptr;
close();
_connectResult = tryConnect();
if (_isConnected || _connectResult.second)
{
// immediate success or error
log_debug("connected successfully");
_socket.connected.send(_socket);
}
else
// by closing the previous file handle _pfd is set to 0.
// creating a new socket in tryConnect may also change the value of fd.
initializePoll(&pfd, 1);
return _isConnected;
}
}
else if( pfd.revents & POLLOUT )
{
int sockerr = checkConnect();
if (_isConnected)
{
_socket.connected.send(_socket);
return true;
}
// something went wrong - look for next addrInfo
log_debug("sockerr is " << sockerr << " try next");
if (++_addrInfoPtr == _addrInfo.impl()->end())
{
// no more addrInfo - propagate error
_connectResult = std::pair<int, const char*>(sockerr, "connect");
_socket.connected.send(_socket);
return true;
}
_connectResult = tryConnect();
if (_isConnected)
{
_socket.connected.send(_socket);
return true;
}
}
return false;
}
} // namespace net
} // namespace cxxtools
fix compile error in tcpsocketimpl
git-svn-id: 40192aece4a9e6664bc9a93aa558322db432a344@1083 15ae5fad-cc11-0410-8fac-bce609e504b0
/*
* Copyright (C) 2009 Marc Boris Duerner, Tommi Maekitalo
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* As a special exception, you may use this file as part of a free
* software library without restriction. Specifically, if other files
* instantiate templates or use macros or inline functions from this
* file, or you compile this file and link it with other files to
* produce an executable, this file does not by itself cause the
* resulting executable to be covered by the GNU General Public
* License. This exception does not however invalidate any other
* reasons why the executable file might be covered by the GNU Library
* General Public License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#ifdef HAVE_ACCEPT4
#include <sys/types.h>
#include <sys/socket.h>
#endif
#include "tcpsocketimpl.h"
#include "tcpserverimpl.h"
#include "cxxtools/net/tcpserver.h"
#include "cxxtools/net/tcpsocket.h"
#include "cxxtools/systemerror.h"
#include "cxxtools/ioerror.h"
#include "cxxtools/log.h"
#include "config.h"
#include "error.h"
#include <cerrno>
#include <cstring>
#include <cassert>
#include <fcntl.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
log_define("cxxtools.net.tcpsocket.impl")
namespace cxxtools
{
namespace net
{
void formatIp(const sockaddr_storage& addr, std::string& str)
{
#ifdef HAVE_INET_NTOP
const sockaddr_in* sa = reinterpret_cast<const sockaddr_in*>(&addr);
char strbuf[INET6_ADDRSTRLEN + 1];
const char* p = inet_ntop(sa->sin_family, &sa->sin_addr, strbuf, sizeof(strbuf));
str = (p == 0 ? "-" : strbuf);
#else
static cxxtools::Mutex monitor;
cxxtools::MutexLock lock(monitor);
const sockaddr_in* sa = reinterpret_cast<const sockaddr_in*>(&addr);
const char* p = inet_ntoa(sa->sin_addr);
if (p)
str = p;
else
str.clear();
#endif
}
TcpSocketImpl::TcpSocketImpl(TcpSocket& socket)
: IODeviceImpl(socket)
, _socket(socket)
, _isConnected(false)
{
}
TcpSocketImpl::~TcpSocketImpl()
{
assert(_pfd == 0);
}
void TcpSocketImpl::close()
{
log_debug("close socket " << _fd);
IODeviceImpl::close();
_isConnected = false;
}
std::string TcpSocketImpl::getSockAddr() const
{
struct sockaddr_storage addr;
socklen_t slen = sizeof(addr);
if (::getsockname(fd(), reinterpret_cast<struct sockaddr*>(&addr), &slen) < 0)
throw SystemError("getsockname");
std::string ret;
formatIp(addr, ret);
return ret;
}
std::string TcpSocketImpl::getPeerAddr() const
{
std::string ret;
formatIp(_peeraddr, ret);
return ret;
}
void TcpSocketImpl::connect(const AddrInfo& addrInfo)
{
log_debug("connect");
this->beginConnect(addrInfo);
this->endConnect();
}
int TcpSocketImpl::checkConnect()
{
log_trace("checkConnect");
int sockerr;
socklen_t optlen = sizeof(sockerr);
// check for socket error
if( ::getsockopt(this->fd(), SOL_SOCKET, SO_ERROR, &sockerr, &optlen) != 0 )
{
// getsockopt failed
int e = errno;
close();
throw SystemError(e, "getsockopt");
}
if (sockerr == 0)
{
log_debug("connected successfully to " << getPeerAddr());
_isConnected = true;
}
return sockerr;
}
void TcpSocketImpl::checkPendingError()
{
if (_connectResult.second)
{
std::pair<int, const char*> p = _connectResult;
_connectResult = std::pair<int, const char*>(0, 0);
if (p.first)
{
throw IOError(getErrnoString(p.first, p.second).c_str());
}
else
{
throw IOError("invalid address information");
}
}
}
std::pair<int, const char*> TcpSocketImpl::tryConnect()
{
log_trace("tryConnect");
assert(_fd == -1);
if (_addrInfoPtr == _addrInfo.impl()->end())
{
log_debug("no more address informations");
return std::pair<int, const char*>(0, "invalid address information");
}
while (true)
{
int fd;
while (true)
{
log_debug("create socket");
fd = ::socket(_addrInfoPtr->ai_family, SOCK_STREAM, 0);
if (fd >= 0)
break;
if (++_addrInfoPtr == _addrInfo.impl()->end())
return std::pair<int, const char*>(errno, "socket");
}
IODeviceImpl::open(fd, true, false);
std::memmove(&_peeraddr, _addrInfoPtr->ai_addr, _addrInfoPtr->ai_addrlen);
log_debug("created socket " << _fd << " max: " << FD_SETSIZE);
if( ::connect(this->fd(), _addrInfoPtr->ai_addr, _addrInfoPtr->ai_addrlen) == 0 )
{
_isConnected = true;
log_debug("connected successfully to " << getPeerAddr());
break;
}
if (errno == EINPROGRESS)
{
log_debug("connect in progress");
break;
}
close();
if (++_addrInfoPtr == _addrInfo.impl()->end())
return std::pair<int, const char*>(errno, "connect");
}
return std::pair<int, const char*>(0, 0);
}
bool TcpSocketImpl::beginConnect(const AddrInfo& addrInfo)
{
log_trace("begin connect");
assert(!_isConnected);
_addrInfo = addrInfo;
_addrInfoPtr = _addrInfo.impl()->begin();
_connectResult = tryConnect();
checkPendingError();
return _isConnected;
}
void TcpSocketImpl::endConnect()
{
log_trace("ending connect");
if(_pfd && ! _socket.wbuf())
{
_pfd->events &= ~POLLOUT;
}
checkPendingError();
if( _isConnected )
return;
try
{
while (true)
{
pollfd pfd;
pfd.fd = this->fd();
pfd.revents = 0;
pfd.events = POLLOUT;
log_debug("wait " << timeout() << " ms");
bool avail = this->wait(this->timeout(), pfd);
if (avail)
{
// something has happened
int sockerr = checkConnect();
if (_isConnected)
return;
if (++_addrInfoPtr == _addrInfo.impl()->end())
{
// no more addrInfo - propagate error
throw IOError(getErrnoString(sockerr, "connect").c_str());
}
}
else if (++_addrInfoPtr == _addrInfo.impl()->end())
{
log_debug("timeout");
throw IOTimeout();
}
close();
_connectResult = tryConnect();
if (_isConnected)
return;
checkPendingError();
}
}
catch(...)
{
close();
throw;
}
}
void TcpSocketImpl::accept(const TcpServer& server, unsigned flags)
{
socklen_t peeraddr_len = sizeof(_peeraddr);
_fd = server.impl().accept(flags, reinterpret_cast <struct sockaddr*>(&_peeraddr), peeraddr_len);
if( _fd < 0 )
throw SystemError("accept");
#ifdef HAVE_ACCEPT4
IODeviceImpl::open(_fd, false, false);
#else
bool inherit = (flags & TcpSocket::INHERIT) != 0;
IODeviceImpl::open(_fd, true, inherit);
#endif
//TODO ECONNABORTED EINTR EPERM
_isConnected = true;
log_debug( "accepted from " << getPeerAddr());
}
void TcpSocketImpl::initWait(pollfd& pfd)
{
IODeviceImpl::initWait(pfd);
if( ! _isConnected )
{
log_debug("not connected, setting POLLOUT ");
pfd.events = POLLOUT;
}
}
bool TcpSocketImpl::checkPollEvent(pollfd& pfd)
{
log_debug("checkPollEvent " << pfd.revents);
if( _isConnected )
return IODeviceImpl::checkPollEvent(pfd);
if ( pfd.revents & POLLERR )
{
AddrInfoImpl::const_iterator ptr = _addrInfoPtr;
if (++ptr == _addrInfo.impl()->end())
{
// not really connected but error
// end of addrinfo list means that no working addrinfo was found
log_debug("no more addrinfos found");
_socket.connected.send(_socket);
return true;
}
else
{
_addrInfoPtr = ptr;
close();
_connectResult = tryConnect();
if (_isConnected || _connectResult.second)
{
// immediate success or error
log_debug("connected successfully");
_socket.connected.send(_socket);
}
else
// by closing the previous file handle _pfd is set to 0.
// creating a new socket in tryConnect may also change the value of fd.
initializePoll(&pfd, 1);
return _isConnected;
}
}
else if( pfd.revents & POLLOUT )
{
int sockerr = checkConnect();
if (_isConnected)
{
_socket.connected.send(_socket);
return true;
}
// something went wrong - look for next addrInfo
log_debug("sockerr is " << sockerr << " try next");
if (++_addrInfoPtr == _addrInfo.impl()->end())
{
// no more addrInfo - propagate error
_connectResult = std::pair<int, const char*>(sockerr, "connect");
_socket.connected.send(_socket);
return true;
}
_connectResult = tryConnect();
if (_isConnected)
{
_socket.connected.send(_socket);
return true;
}
}
return false;
}
} // namespace net
} // namespace cxxtools
|
// -*- mode: c++; c-basic-offset:4 -*-
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
// (c) COPYRIGHT URI/MIT 1995-1999
// Please read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
// jhrg,jimg James Gallagher <jgallagher@gso.uri.edu>
// Implementation for class Vector. This class is the basis for all the
// vector-type classes in libdap's <Array, List>.
//
// 11/21/95 jhrg
#include "config.h"
#include <cstring>
#include <cassert>
//#define DODS_DEBUG 1
#include <sstream>
#include <vector>
#include <algorithm>
#include <typeinfo>
#include <stdint.h>
#include "crc.h"
#include "Vector.h"
#include "Marshaller.h"
#include "UnMarshaller.h"
#include "D4StreamMarshaller.h"
#include "D4StreamUnMarshaller.h"
#include "D4Enum.h"
#include "Type.h"
#include "dods-datatypes.h"
#include "escaping.h"
#include "util.h"
#include "debug.h"
#include "InternalErr.h"
#undef CLEAR_LOCAL_DATA
using std::cerr;
using std::endl;
namespace libdap {
void Vector::m_duplicate(const Vector & v)
{
d_length = v.d_length;
// _var holds the type of the elements. That is, it holds a BaseType
// which acts as a template for the type of each element.
if (v.d_proto) {
d_proto = v.d_proto->ptr_duplicate(); // use ptr_duplicate()
d_proto->set_parent(this); // ptr_duplicate does not set d_parent.
}
else {
d_proto = 0;
}
// d_compound_buf and d_buf (further down) hold the values of the Vector. The field
// d_compound_buf is used when the Vector holds non-numeric data (including strings
// although it used to be that was not the case jhrg 2/10/05) while d_buf
// holds numeric values.
if (v.d_compound_buf.empty()) {
d_compound_buf = v.d_compound_buf;
}
else {
// Failure to set the size will make the [] operator barf on the LHS
// of the assignment inside the loop.
d_compound_buf.resize(d_length);
for (int i = 0; i < d_length; ++i) {
// There's no need to call set_parent() for each element; we
// maintain the back pointer using the d_proto member. These
// instances are used to hold _values_ only while the d_proto
// field holds the type information for the elements.
d_compound_buf[i] = v.d_compound_buf[i]->ptr_duplicate();
}
}
// copy the strings. This copies the values.
d_str = v.d_str;
// copy numeric values if there are any.
d_buf = 0; // init to null
if (v.d_buf) // only copy if data present
val2buf(v.d_buf); // store v's value in this's _BUF.
d_capacity = v.d_capacity;
}
/**
* @return whether the type of this Vector is a cardinal type
* (i.e., stored in d_buf)
*/
bool Vector::m_is_cardinal_type() const
{
// Not cardinal if no d_proto at all!
if (!d_proto) {
return false;
}
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
// New cardinal types for DAP4
case dods_int8_c:
case dods_uint8_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
return true;
break;
// These must be handled differently.
case dods_str_c:
case dods_url_c:
case dods_opaque_c:
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
return false;
break;
default:
assert("Vector::var: Unrecognized type");
return false;
}
}
/**
* Create _buf so that it can store numElts of the
* (assumed) cardinal type. This create storage for
* width() * numElts bytes.
* If _buf already exists, this DELETES IT and creates a new one.
* So don't use this if you want to keep the original _buf data around.
* This also sets the valueCapacity().
* @param numEltsOfType the number of elements of the cardinal type in var()
that we want storage for.
* @return the size of the buffer created.
* @exception if the Vector's type is not cardinal type.
*/
unsigned int Vector::m_create_cardinal_data_buffer_for_type(unsigned int numEltsOfType)
{
// Make sure we HAVE a _var, or we cannot continue.
if (!d_proto) {
throw InternalErr(__FILE__, __LINE__, "create_cardinal_data_buffer_for_type: Logic error: _var is null!");
}
// Make sure we only do this for the correct data types.
if (!m_is_cardinal_type()) {
throw InternalErr(__FILE__, __LINE__, "create_cardinal_data_buffer_for_type: incorrectly used on Vector whose type was not a cardinal (simple data types).");
}
m_delete_cardinal_data_buffer();
// Actually new up the array with enough bytes to hold numEltsOfType of the actual type.
unsigned int bytesPerElt = d_proto->width();
unsigned int bytesNeeded = bytesPerElt * numEltsOfType;
d_buf = new char[bytesNeeded];
d_capacity = numEltsOfType;
return bytesNeeded;
}
/** Delete d_buf and zero it and d_capacity out */
void Vector::m_delete_cardinal_data_buffer()
{
delete[] d_buf;
d_buf = 0;
d_capacity = 0;
}
/** Helper to reduce cut and paste in the virtual's.
*
*/
template<class CardType>
void Vector::m_set_cardinal_values_internal(const CardType* fromArray, int numElts)
{
if (numElts < 0) {
throw InternalErr(__FILE__, __LINE__, "Logic error: Vector::set_cardinal_values_internal() called with negative numElts!");
}
if (!fromArray) {
throw InternalErr(__FILE__, __LINE__, "Logic error: Vector::set_cardinal_values_internal() called with null fromArray!");
}
set_length(numElts);
m_create_cardinal_data_buffer_for_type(numElts);
memcpy(d_buf, fromArray, numElts * sizeof(CardType));
set_read_p(true);
}
/** The Vector constructor requires the name of the variable to be
created, and a pointer to an object of the type the Vector is to
hold. The name may be omitted, which will create a nameless
variable. The template object may not be omitted.
@param n A string containing the name of the variable to be
created.
@param v A pointer to a prototype for elements.
@param t The type of the resulting Vector object, from the Type
enum list. There is no DAP2 Vector object, so all uses of this
method will be from the Array class. This defaults to
<tt>dods_null_c</tt>.
@see Type
@brief The Vector constructor. */
Vector::Vector(const string & n, BaseType * v, const Type & t, bool is_dap4 /* default:false */) :
BaseType(n, t, is_dap4), d_length(-1), d_proto(0), d_buf(0), d_compound_buf(0), d_capacity(0)
{
if (v)
add_var(v);
DBG2(cerr << "Entering Vector ctor for object: " << this << endl);
if (d_proto)
d_proto->set_parent(this);
}
/** The Vector server-side constructor requires the name of the variable
to be created, the dataset name from which this Vector is created, and
a pointer to an object of the type the Vector is to hold. The
name may be omitted, which will create a nameless variable.
The template object may not be omitted.
@param n A string containing the name of the variable to be
created.
@param d A string containing the dataset name from which the variable is
being created.
@param v A pointer to a prototype for elements.
@param t The type of the resulting Vector object, from the Type
enum list. There is no DAP2 Vector object, so all uses of this
method will be from the Array class. This defaults to
<tt>dods_null_c</tt>.
@see Type
@brief The Vector constructor. */
Vector::Vector(const string & n, const string &d, BaseType * v, const Type & t, bool is_dap4 /* default:false */) :
BaseType(n, d, t, is_dap4), d_length(-1), d_proto(0), d_buf(0), d_compound_buf(0), d_capacity(0)
{
if (v)
add_var(v);
DBG2(cerr << "Entering Vector ctor for object: " << this << endl);
if (d_proto)
d_proto->set_parent(this);
}
/** The Vector copy constructor. */
Vector::Vector(const Vector & rhs) :
BaseType(rhs)
{
DBG2(cerr << "Entering Vector const ctor for object: " << this <<
endl); DBG2(cerr << "RHS: " << &rhs << endl);
m_duplicate(rhs);
}
Vector::~Vector()
{
DBG2(cerr << "Entering ~Vector (" << this << ")" << endl);
delete d_proto;
d_proto = 0;
// Clears all buffers
clear_local_data();
DBG2(cerr << "Exiting ~Vector" << endl);
}
Vector & Vector::operator=(const Vector & rhs)
{
if (this == &rhs)
return *this;
dynamic_cast<BaseType &> (*this) = rhs;
m_duplicate(rhs);
return *this;
}
void Vector::set_name(const std::string& name)
{
BaseType::set_name(name);
// We need to set the prototype name as well since
// this is what gets output in the dds! Otherwise, there's a mismatch.
if (d_proto) {
d_proto->set_name(name);
}
}
int Vector::element_count(bool leaves)
{
if (!leaves)
return 1;
else
return d_proto->element_count(leaves);
// var() only works for simple types!
// jhrg 8/19/13 return var(0)->element_count(leaves);
}
// These mfuncs set the _send_p and _read_p fields of BaseType. They differ
// from BaseType's version in that they set both the Vector object's copy of
// _send_p (_read_p) but also _VAR's copy. This does not matter much when _VAR
// is a scalar, but does matter when it is an aggregate.
/** This function sets the <tt>send_p</tt> flag for both the Vector itself
and its element template. This does not matter much when the
Vector contains simple data types, but does become significant
when the Vector contains compound types.
@brief Indicates that the data is ready to send. */
void Vector::set_send_p(bool state)
{
d_proto->set_send_p(state);
BaseType::set_send_p(state);
}
/** This function sets the <tt>read_p</tt> flag for both the Vector itself
and its element template. This does not matter much when the
Vector contains simple data types, but does become significant
when the Vector contains compound types.
@brief Indicates that the data is ready to send. */
void Vector::set_read_p(bool state)
{
if (d_proto) {
d_proto->set_read_p(state);
}
BaseType::set_read_p(state);
}
/** Returns a copy of the template array element. If the Vector contains
simple data types, the template will contain the value of the last
vector element accessed with the <code>Vector::var(int i)</code> function,
if any. If no such access has been made, or if the Vector contains
compound data types, the value held by the template instance is
undefined.
Note that the parameter <i>exact_match</i> is not used by this mfunc.
@param n The name of the variable to find.
@param exact Unused.
@param s Pointer to a BaseType Pointer Stack. Use this stack to record
the path to the variable. By default this pointer is null, in which case
it is not used.
@return A pointer to the BaseType if found, otherwise null.
@see Vector::var */
BaseType *Vector::var(const string &n, bool exact, btp_stack *s)
{
string name = www2id(n);
DBG2(cerr << "Vector::var: Looking for " << name << endl);
// If this is a Vector of constructor types, look for 'name' recursively.
// Make sure to check for the case where name is the default (the empty
// string). 9/1/98 jhrg
if (d_proto->is_constructor_type()) {
if (name == "" || d_proto->name() == name) {
if (s)
s->push(this);
return d_proto;
}
else {
BaseType * result = d_proto->var(name, exact, s);
if (result && s)
s->push(this);
return result;
}
}
else {
return d_proto;
}
}
/** This version of var(...) searches for <i>name</i> and returns a
pointer to the BaseType object if found. It uses the same search
algorithm as above when <i>exact_match</i> is false. In addition to
returning a pointer to the variable, it pushes onto <i>s</i> a
BaseType pointer to each constructor type that ultimately contains
<i>name</i>.
@param n Find the variable whose name is <i>name</i>.
@param s Record the path to <i>name</i>.
@return A pointer to the named variable. */
BaseType *Vector::var(const string & n, btp_stack & s)
{
string name = www2id(n);
if (d_proto->is_constructor_type())
return d_proto->var(name, s);
else {
s.push((BaseType *) this);
return d_proto;
}
}
/** Returns a pointer to the specified Vector element. The return
pointer will reference the element itself, so multiple calls to this
method should save each value before making the next call.
@param i The index of the desired Vector element. Zero
indicates the first element of the Vector.
@return A pointer to a BaseType class instance containing
the value of the indicated element. The BaseType pointer is locally
maintained and should not be deleted or referenced. Extract the value
right after the method returns.
@see BaseType::var */
BaseType *Vector::var(unsigned int i)
{
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
// Transfer the ith value to the BaseType *d_proto
d_proto->val2buf(d_buf + (i * d_proto->width()));
return d_proto;
break;
case dods_str_c:
case dods_url_c:
d_proto->val2buf(&d_str[i]);
return d_proto;
break;
case dods_opaque_c:
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
return d_compound_buf[i];
break;
default:
throw Error ("Vector::var: Unrecognized type");
break;
}
return 0;
}
/** Returns the number of bytes needed to hold the entire
array. This is equal to \c length() (the number of elements in
in the array) times the width of each
element.
@brief Returns the width of the data, in bytes. */
unsigned int Vector::width(bool constrained) const
{
// Jose Garcia
assert(d_proto);
return length() * d_proto->width(constrained);
}
/** Returns the number of elements in the vector. Note that some
child classes of Vector use the length of -1 as a flag value.
@see Vector::append_dim */
int Vector::length() const
{
return d_length;
}
/** Sets the length of the vector. This function does not allocate
any new space. */
void Vector::set_length(int l)
{
d_length = l;
}
/** Resizes a Vector. If the input length is greater than the
current length of the Vector, new memory is allocated (the
Vector moved if necessary), and the new entries are appended to
the end of the array and padded with Null values. If the input
length is shorter, the tail values are discarded.
@note This method is applicable to the compound types only.
*/
void Vector::vec_resize(int l)
{
// I added this check, which alters the behavior of the method. jhrg 8/14/13
if (m_is_cardinal_type())
throw InternalErr(__FILE__, __LINE__, "Vector::vec_resize() is applicable to compound types only");
d_compound_buf.resize((l > 0) ? l : 0, 0); // Fill with NULLs
d_capacity = l; // capacity in terms of number of elements.
}
/** @brief read data into a variable for later use
Most uses of a variable are to either serialize its data to a stream of
some sort or to read values from some stream and intern those in the
variable for later use. These operations are perform by serialize()
and deserialize() which follow. This function performs essentially both
of these operations without actually using a stream device. The data are
read using the read() method(s) and loaded into the variables directly.
This method is intended to be used by objects which transform DAP objects
like the DataDDS into an ASCII CSV representation.
@note A DAP2-only method
@param eval A reference to a constraint evaluator
@param dds The complete DDS to which this variable belongs */
void Vector::intern_data(ConstraintEvaluator &eval, DDS &dds)
{
DBG(cerr << "Vector::intern_data: " << name() << endl);
if (!read_p())
read(); // read() throws Error and InternalErr
// length() is not capacity; it must be set explicitly in read().
int num = length();
switch (d_proto->type()) {
case dods_byte_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
// For these cases, read() puts the data into d_buf,
// which is what we need.
break;
case dods_str_c:
case dods_url_c:
// For these cases, read() will put the data into d_str[],
// which is also what we need.
break;
case dods_array_c:
// This is an error since there can never be an Array of Array.
throw InternalErr(__FILE__, __LINE__, "Array of Array not supported.");
break;
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
DBG(cerr << "Vector::intern_data: found ctor" << endl);
// For these cases, we need to call read() for each of the 'num'
// elements in the 'd_compound_buf[]' array of BaseType object pointers.
if (d_compound_buf.capacity() == 0)
throw InternalErr(__FILE__, __LINE__, "The capacity of *this* vector is 0.");
for (int i = 0; i < num; ++i)
d_compound_buf[i]->intern_data(eval, dds);
break;
default:
throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
break;
}
}
/** @brief Serialize a Vector.
This uses the Marshaler class to encode each element of a cardinal
array. For Arrays of Str and Url types, send the element count over
as a prefix to the data so that deserialize will know how many elements
to read.
NB: Arrays of cardinal types must already be in BUF (in the local machine's
representation) <i>before</i> this call is made.
*/
bool Vector::serialize(ConstraintEvaluator & eval, DDS & dds, Marshaller &m, bool ce_eval)
{
dds.timeout_on();
if (!read_p())
read(); // read() throws Error and InternalErr
if (ce_eval && !eval.eval_selection(dds, dataset()))
return true;
dds.timeout_off();
// length() is not capacity; it must be set explicitly in read().
int num = length();
bool status = false;
switch (d_proto->type()) {
case dods_byte_c:
m.put_vector(d_buf, num, *this);
status = true;
break;
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
m.put_vector(d_buf, num, d_proto->width(), *this);
status = true;
break;
case dods_str_c:
case dods_url_c:
if (d_str.capacity() == 0)
throw InternalErr(__FILE__, __LINE__, "The capacity of the string vector is 0");
m.put_int(num);
for (int i = 0; i < num; ++i)
m.put_str(d_str[i]);
status = true;
break;
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
//Jose Garcia
// Not setting the capacity of d_compound_buf is an internal error.
if (d_compound_buf.capacity() == 0)
throw InternalErr(__FILE__, __LINE__, "The capacity of *this* vector is 0.");
m.put_int(num);
status = true;
for (int i = 0; i < num && status; ++i)
status = status && d_compound_buf[i]->serialize(eval, dds, m, false);
break;
default:
throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
break;
}
#ifdef CLEAR_LOCAL_DATA
clear_local_data();
#endif
return status;
}
// Read an object from the network and internalize it. For a Vector this is
// handled differently for a `cardinal' type. Vectors of Cardinals are
// stored using the `C' representations because these objects often are used
// to build huge arrays (e.g., an array of 1024 by 1024 bytes). However,
// arrays of non-cardinal types are stored as Vectors of the C++ objects or
// DAP2 objects (Str and Url are vectors of the string class, Structure, ...,
// Grid are vectors of the libdap Structure, ... classes).
//
// The boolean parameter REUSE determines whether internal storage is reused
// or not. If true, the _buf member is assumed to be large enough to hold the
// incoming cardinal data and is *not* reallocated. If false, new storage is
// allocated. If the internal buffer has not yet been allocated, then this
// parameter has no effect (i.e., storage is allocated). This parameter
// effects storage for cardinal data only.
//
// Returns: True is successful, false otherwise.
bool Vector::deserialize(UnMarshaller &um, DDS * dds, bool reuse)
{
unsigned int num;
unsigned i = 0;
switch (d_proto->type()) {
case dods_byte_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
um.get_int((int &) num);
DBG(cerr << "Vector::deserialize: num = " << num << endl);
DBG(cerr << "Vector::deserialize: length = " << length() << endl);
if (length() == -1)
set_length(num);
if (num != (unsigned int) length())
throw InternalErr(__FILE__, __LINE__, "The server sent declarations and data with mismatched sizes for the variable '" + name() + "'.");
if (!d_buf || !reuse) {
// Make d_buf be large enough for length() elements of _var->type()
// m_create...() deletes the old buffer.
m_create_cardinal_data_buffer_for_type(length());
DBG(cerr << "Vector::deserialize: allocating "
<< width() << " bytes for an array of "
<< length() << " " << d_proto->type_name() << endl);
}
if (d_proto->type() == dods_byte_c)
um.get_vector((char **) &d_buf, num, *this);
else
um.get_vector((char **) &d_buf, num, d_proto->width(), *this);
DBG(cerr << "Vector::deserialize: read " << num << " elements\n");
break;
case dods_str_c:
case dods_url_c:
um.get_int((int &) num);
if (length() == -1)
set_length(num);
if (num != (unsigned int) length())
throw InternalErr(__FILE__, __LINE__, "The client sent declarations and data with mismatched sizes.");
d_str.resize((num > 0) ? num : 0); // Fill with NULLs
d_capacity = num; // capacity is number of strings we can fit.
for (i = 0; i < num; ++i) {
string str;
um.get_str(str);
d_str[i] = str;
}
break;
case dods_array_c:
// TODO
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
um.get_int((int &) num);
if (length() == -1)
set_length(num);
if (num != (unsigned int) length())
throw InternalErr(__FILE__, __LINE__, "The client sent declarations and data with mismatched sizes.");
vec_resize(num);
for (i = 0; i < num; ++i) {
d_compound_buf[i] = d_proto->ptr_duplicate();
d_compound_buf[i]->deserialize(um, dds);
}
break;
default:
throw InternalErr(__FILE__, __LINE__, "Unknown type!");
break;
}
return false;
}
void Vector::compute_checksum(Crc32 &checksum)
{
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_float64_c:
case dods_enum_c:
checksum.AddData(reinterpret_cast<uint8_t*>(d_buf), length() * d_proto->width());
break;
case dods_str_c:
case dods_url_c:
for (int64_t i = 0, e = length(); i < e; ++i)
checksum.AddData(reinterpret_cast<const uint8_t*>(d_str[i].data()), d_str[i].length());
break;
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
d_proto->compute_checksum(checksum);
break;
case dods_array_c: // No array of array
case dods_grid_c: // No grids in DAP4
default:
throw InternalErr(__FILE__, __LINE__, "Unknown or unsupported datatype (" + d_proto->type_name() + ").");
break;
}
}
void Vector::intern_data(Crc32 &checksum/*, DMR &dmr, ConstraintEvaluator &eval*/)
{
if (!read_p())
read(); // read() throws Error and InternalErr
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
case dods_str_c:
case dods_url_c:
compute_checksum(checksum);
break;
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
assert(d_compound_buf.capacity() != 0);
for (int i = 0, e = length(); i < e; ++i)
d_compound_buf[i]->intern_data(checksum/*, dmr, eval*/);
break;
case dods_array_c: // No Array of Array in DAP4 either...
case dods_grid_c:
default:
throw InternalErr(__FILE__, __LINE__, "Unknown or unsupported datatype (" + d_proto->type_name() + ").");
break;
}
}
void
Vector::serialize(D4StreamMarshaller &m, DMR &dmr, /*ConstraintEvaluator &eval,*/ bool filter /*= false*/)
{
if (!read_p())
read(); // read() throws Error and InternalErr
#if 0
if (filter && !eval.eval_selection(dmr, dataset()))
return true;
#endif
int64_t num = length(); // The constrained length in elements
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
m.put_vector(d_buf, num);
break;
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
m.put_vector(d_buf, num, d_proto->width());
break;
case dods_enum_c:
if (d_proto->width() == 1)
m.put_vector(d_buf, num);
else
m.put_vector(d_buf, num, d_proto->width());
break;
case dods_float32_c:
m.put_vector_float32(d_buf, num);
break;
case dods_float64_c:
m.put_vector_float64(d_buf, num);
break;
case dods_str_c:
case dods_url_c:
assert((int64_t)d_str.capacity() >= num);
for (int64_t i = 0; i < num; ++i)
m.put_str(d_str[i]);
break;
case dods_array_c:
throw InternalErr(__FILE__, __LINE__, "Array of Array not allowed.");
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
assert(d_compound_buf.capacity() >= 0);
for (int64_t i = 0; i < num; ++i)
d_compound_buf[i]->serialize(m, dmr, /*eval,*/ filter);
break;
case dods_grid_c:
throw InternalErr(__FILE__, __LINE__, "Grid is not part of DAP4.");
default:
throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
break;
}
#ifdef CLEAR_LOCAL_DATA
clear_local_data();
#endif
}
void
Vector::deserialize(D4StreamUnMarshaller &um, DMR &dmr)
{
if (m_is_cardinal_type()) {
if (d_buf)
m_delete_cardinal_data_buffer();
if (!d_buf)
m_create_cardinal_data_buffer_for_type(length());
}
DBG(cerr << "Vector::deserialize, " << name() << ", length(): " << length() << endl);
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
um.get_vector((char *)d_buf, length());
break;
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
um.get_vector((char *)d_buf, length(), d_proto->width());
break;
case dods_enum_c:
if (d_proto->width() == 1)
um.get_vector((char *)d_buf, length());
else
um.get_vector((char *)d_buf, length(), d_proto->width());
break;
case dods_float32_c:
um.get_vector_float32((char *)d_buf, length());
break;
case dods_float64_c:
um.get_vector_float64((char *)d_buf, length());
break;
case dods_str_c:
case dods_url_c: {
int64_t len = length();
d_str.resize((len > 0) ? len : 0); // Fill with NULLs
d_capacity = len; // capacity is number of strings we can fit.
for (int64_t i = 0; i < len; ++i) {
um.get_str(d_str[i]);
}
break;
}
case dods_array_c:
throw InternalErr(__FILE__, __LINE__, "Array of Array not allowed.");
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c: {
vec_resize(length());
for (int64_t i = 0, end = length(); i < end; ++i) {
d_compound_buf[i] = d_proto->ptr_duplicate();
d_compound_buf[i]->deserialize(um, dmr);
}
break;
}
case dods_grid_c:
throw InternalErr(__FILE__, __LINE__, "Grid is not part of DAP4.");
default:
throw InternalErr(__FILE__, __LINE__, "Unknown type.");
break;
}
}
/** Copies data into the class instance buffer. This function
assumes that the input \e val points to memory which
contains, in row major order, enough elements of the correct
type to fill the array. For an array of a cardinal type the
memory is simply copied in whole into the Vector buffer.
If the variable has already been constrained, this method will load only
number of values/bytes specified by that constraint and will load them
into the 'front' of the object's internal buffer. This is where serialize()
expects to find the data.
For a Vector of Str (OPeNDAP Strings), this assumes \e val points to an
array of C++ strings.
This method should not be used for Structure, Sequence or Grid.
@brief Reads data into the Vector buffer.
@exception InternalErr Thrown if called for Structure, Sequence or
Grid.
@return The number of bytes used by the array.
@param val A pointer to the input data.
@param reuse A boolean value, indicating whether the class
internal data storage can be reused or not. If this argument is
TRUE, the class buffer is assumed to be large enough to hold the
incoming data, and it is <i>not</i> reallocated. If FALSE, new
storage is allocated. If the internal buffer has not been
allocated at all, this argument has no effect. */
unsigned int Vector::val2buf(void *val, bool reuse)
{
// Jose Garcia
// I *think* this method has been mainly designed to be use by read which
// is implemented in the surrogate library. Passing NULL as a pointer to
// this method will be an error of the creator of the surrogate library.
// Even though I recognize the fact that some methods inside libdap++ can
// call val2buf, I think by now no coding bugs such as misusing val2buf
// will be in libdap++, so it will be an internal error from the
// surrogate library.
if (!val)
throw InternalErr(__FILE__, __LINE__, "The incoming pointer does not contain any data.");
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
#if 0
if (d_buf && !reuse)
m_delete_cardinal_data_buffer();
#endif
// First time or no reuse (free'd above)
if (!d_buf || !reuse)
m_create_cardinal_data_buffer_for_type(length());
// width(true) returns the size in bytes given the constraint
memcpy(d_buf, val, width(true));
break;
case dods_str_c:
case dods_url_c:
// Assume val points to an array of C++ string objects. Copy
// them into the vector<string> field of this object.
// Note: d_length is the number of elements in the Vector
d_str.resize(d_length);
d_capacity = d_length;
for (int i = 0; i < d_length; ++i)
d_str[i] = *(static_cast<string *> (val) + i);
break;
default:
throw InternalErr(__FILE__, __LINE__, "Vector::val2buf: bad type");
}
return width(true);
}
/** Copies data from the Vector buffer. This function assumes that
<i>val</i> points to an array large enough to hold N instances of
the `C' representation of the \e numeric element type or C++ string
objects. Never call this method for constructor types Structure,
Sequence or Grid.
When reading data out of a variable that has been constrained, this method
assumes the N values/bytes of constrained data start at the beginning
of the object's internal buffer. For example, do not load an entire
Vector's data using val2buf(), constrain and then use this method to
get the data. Unless your constraint starts with the [0]th element, the
result will not be the correct values.
In the case of a Vector of Str objects, this method will return an array
of C++ std::string objects.
@note It's best to define the pointer to reference the data as
'char *data' and then call this method using '..->buf2val((void**)&data)'.
Then free the storage once you're done using 'delete[] data'. It's not
correct C++ to use 'delete[]' on a void pointer and the allocated memory
\e is an array of char, so 'delete[]' is needed.
@return The number of bytes used to store the array.
@param val A pointer to a pointer to the memory into which the
class data will be copied. If the value pointed to is NULL,
memory will be allocated to hold the data, and the pointer value
modified accordingly. The calling program is responsible for
deallocating the memory indicated by this pointer.
@exception InternalErr Thrown if \e val is null.
@see Vector::set_vec */
unsigned int Vector::buf2val(void **val)
{
// Jose Garcia
// The same comment in Vector::val2buf applies here!
if (!val)
throw InternalErr(__FILE__, __LINE__, "NULL pointer.");
unsigned int wid = static_cast<unsigned int> (width(true /* constrained */));
// This is the width computed using length(). The
// length() property is changed when a projection
// constraint is applied. Thus this is the number of
// bytes in the buffer given the current constraint.
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
if (!d_buf)
throw InternalErr(__FILE__, __LINE__, "Vector::buf2val: Logic error: called when cardinal type data buffer was empty!");
if (!*val)
*val = new char[wid];
memcpy(*val, d_buf, wid);
return wid;
break;
case dods_str_c:
case dods_url_c: {
if (d_str.empty())
throw InternalErr(__FILE__, __LINE__, "Vector::buf2val: Logic error: called when string data buffer was empty!");
if (!*val)
*val = new string[d_length];
for (int i = 0; i < d_length; ++i)
*(static_cast<string *> (*val) + i) = d_str[i];
return width();
break;
}
default:
throw InternalErr(__FILE__, __LINE__, "Vector::buf2val: bad type");
}
//return wid;
}
/** Sets an element of the vector to a given value. If the type of
the input and the type of the Vector do not match, an error
condition is returned.
Use this function only with Vectors containing compound
types. See \c buf2val() or the \c set_value() methods to access
members of Vector containing simple types.
@note This method copies \e val; the caller is responsible for deleting
instance passed as the actual parameter.
@brief Sets element <i>i</i> to value <i>val</i>.
@return void
@exception InternalErr Thrown if \e i is out of range, \e val is null or
there was a type mismatch between the BaseType referenced by \e val and
the \e ith element of this Vector.
@param i The index of the element to be changed.
@param val A pointer to the value to be inserted into the
array.
@see Vector::buf2val */
void Vector::set_vec(unsigned int i, BaseType * val)
{
Vector::set_vec_nocopy(i, val->ptr_duplicate());
}
/** @brief Sets element <i>i</i> to value <i>val</i>.
@note This method does not copy \e val; this class will free the instance
when the variable is deleted or when clear_local_data() is called.
@see Vector::set_vec() */
void Vector::set_vec_nocopy(unsigned int i, BaseType * val)
{
// Jose Garcia
// This is a public method which allows users to set the elements
// of *this* vector. Passing an invalid index, a NULL pointer or
// mismatching the vector type are internal errors.
if (i >= static_cast<unsigned int> (d_length))
throw InternalErr(__FILE__, __LINE__, "Invalid data: index too large.");
if (!val)
throw InternalErr(__FILE__, __LINE__, "Invalid data: null pointer to BaseType object.");
if (val->type() != d_proto->type())
throw InternalErr(__FILE__, __LINE__, "invalid data: type of incoming object does not match *this* vector type.");
if (i >= d_compound_buf.capacity())
vec_resize(i + 10);
d_compound_buf[i] = val;
}
/**
* Remove any read or set data in the private data of this Vector,
* setting read_p() to false.
* Essentially clears the _buf, d_str, and d_compound_buf of any data.
* Useful for tightening up memory when the data is no longer needed,
* but the object cannot yet be destroyed.
*
* On exit: get_value_capacity() == 0 && !read_p()
*/
void Vector::clear_local_data()
{
if (d_buf) {
delete[] d_buf;
d_buf = 0;
}
for (unsigned int i = 0; i < d_compound_buf.size(); ++i) {
delete d_compound_buf[i];
d_compound_buf[i] = 0;
}
// Force memory to be reclaimed.
d_compound_buf.resize(0);
d_str.resize(0);
d_capacity = 0;
set_read_p(false);
}
/**
* Return the capacity of the Vector in terms of number of
* elements of its data type that it can currently hold (i.e. not bytes).
* For example, this could be
* the size of the _buf array in bytes / sizeof(T) for the cardinal
* types T, or the capacity of the d_str vector if T is string or url type.
*/
unsigned int Vector::get_value_capacity() const
{
return d_capacity;
}
/**
* Allocate enough memory for the Vector to contain
* numElements data elements of the Vector's type.
* Must be used before set_value_slice_from_row_major_vector
* to ensure memory exists.
* @param numElements the number of elements of the Vector's type
* to preallocate storage for.
* @exception if the memory cannot be allocated
*/
void Vector::reserve_value_capacity(unsigned int numElements)
{
if (!d_proto) {
throw InternalErr(__FILE__, __LINE__, "reserve_value_capacity: Logic error: _var is null!");
}
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
// Make _buf be the right size and set _capacity
m_create_cardinal_data_buffer_for_type(numElements);
break;
case dods_str_c:
case dods_url_c:
// Make sure the d_str has enough room for all the strings.
// Technically not needed, but it will speed things up for large arrays.
d_str.reserve(numElements);
d_capacity = numElements;
break;
case dods_array_c:
throw InternalErr(__FILE__, __LINE__, "reserve_value_capacity: Arrays not supported!");
break;
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
// not clear anyone will go this path, but best to be complete.
d_compound_buf.reserve(numElements);
d_capacity = numElements;
break;
default:
throw InternalErr(__FILE__, __LINE__, "reserve_value_capacity: Unknown type!");
break;
} // switch
}
/**
* Make sure there's storage allocated for the current length()
* of the Vector.
* Same as reserveValueCapacity(length())
*/
void Vector::reserve_value_capacity()
{
// Use the current length of the vector as the reserve amount.
reserve_value_capacity(length());
}
/**
* Copy rowMajorData.length() elements currently in a rowMajorData buffer
* into this value buffer starting at element index startElement and
* continuing up to startElement+rowMajorData.length()-1
*
* This is used for aggregating together smaller rowMajor vectors
* into a larger one.
*
* Note: unlike the other set_value calls, this does NOT set read_p()
* since it is assumed to be used as a partial read and the caller
* is expected to set_read_p() when the data is complete.
*
* ASSUMES: rowMajorData.read_p() so that the data is valid!
* ASSUMES: this Vector has enough value_capacity() to contain
* all the elements such that:
* startElement + rowMajorData.length()
* <= this->value_capacity().
* ASSUMES: the data type of this->var() and rowMajorData.var()
* MUST be non-NULL and be the same!
*
* @param rowMajorDataC the vector from which to copy data,
* assumed already read in or set.
* @param startElement the element index
* (NOT byte, but rather data type element)
* to place the first data value.
* @return the number of elements added, such that:
* startElement + the return value is the next "free" element.
*/
unsigned int
Vector::set_value_slice_from_row_major_vector(const Vector& rowMajorDataC, unsigned int startElement)
{
static const string funcName = "set_value_slice_from_row_major_vector:";
// semantically const from the caller's viewpoint, but some calls are not syntactic const.
Vector& rowMajorData = const_cast<Vector&>(rowMajorDataC);
bool typesMatch = rowMajorData.var() && d_proto && (rowMajorData.var()->type() == d_proto->type());
if (!typesMatch) {
throw InternalErr(__FILE__, __LINE__, funcName + "Logic error: types do not match so cannot be copied!");
}
// Make sure the data exists
if (!rowMajorData.read_p()) {
throw InternalErr(__FILE__, __LINE__,
funcName + "Logic error: the Vector to copy data from has !read_p() and should have been read in!");
}
// Check this otherwise the static_cast<unsigned int> below will do the wrong thing.
if (rowMajorData.length() < 0) {
throw InternalErr(__FILE__, __LINE__,
funcName
+ "Logic error: the Vector to copy data from has length() < 0 and was probably not initialized!");
}
// The read-in capacity had better be at least the length (the amount we will copy) or we'll memcpy into bad memory
// I imagine we could copy just the capacity rather than throw, but I really think this implies a problem to be addressed.
if (rowMajorData.get_value_capacity() < static_cast<unsigned int>(rowMajorData.length())) {
throw InternalErr(__FILE__, __LINE__,
funcName
+ "Logic error: the Vector to copy from has a data capacity less than its length, can't copy!");
}
// Make sure there's enough room in this Vector to store all the elements requested. Again,
// better to throw than just copy what we can since it implies a logic error that needs to be solved.
if (d_capacity < (startElement + rowMajorData.length())) {
throw InternalErr(__FILE__, __LINE__,
funcName + "Logic error: the capacity of this Vector cannot hold all the data in the from Vector!");
}
// OK, at this point we're pretty sure we can copy the data, but we have to do it differently depending on type.
switch (d_proto->type()) {
case dods_int8_c:
case dods_uint8_c:
case dods_byte_c:
case dods_char_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c: {
if (!d_buf) {
throw InternalErr(__FILE__, __LINE__, funcName + "Logic error: this->_buf was unexpectedly null!");
}
if (!rowMajorData.d_buf) {
throw InternalErr(__FILE__, __LINE__, funcName + "Logic error: rowMajorData._buf was unexpectedly null!");
}
// memcpy the data into this, taking care to do ptr arithmetic on bytes and not sizeof(element)
int varWidth = d_proto->width();
char* pFromBuf = rowMajorData.d_buf;
int numBytesToCopy = rowMajorData.width(true);
char* pIntoBuf = d_buf + (startElement * varWidth);
memcpy(pIntoBuf, pFromBuf, numBytesToCopy);
break;
}
case dods_str_c:
case dods_url_c:
// Strings need to be copied directly
for (unsigned int i = 0; i < static_cast<unsigned int>(rowMajorData.length()); ++i) {
d_str[startElement + i] = rowMajorData.d_str[i];
}
break;
case dods_array_c:
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
// Not sure that this function will be used for these type of nested objects, so I will throw here.
throw InternalErr(__FILE__, __LINE__,
funcName + "Unimplemented method for Vectors of type: array, opaque, structure, sequence or grid.");
break;
default:
throw InternalErr(__FILE__, __LINE__, funcName + ": Unknown type!");
break;
} // switch (_var->type())
// This is how many elements we copied.
return (unsigned int) rowMajorData.length();
}
/**
* Does the C++ type correspond to the DAP Type enum value? This works only for
* numeric cardinal types. For Enums, pass the value of element_type(); for all
* others use type().
* @param t
* @param dt
* @return True if the types match, false otherwise
*/
template <typename T>
static bool types_match(Type t, T *cpp_var)
{
switch (t) {
case dods_byte_c:
case dods_char_c:
case dods_uint8_c:
return typeid(cpp_var) == typeid(dods_byte*);
case dods_int8_c:
return typeid(cpp_var) == typeid(dods_int8*);
case dods_int16_c:
return typeid(cpp_var) == typeid(dods_int16*);
case dods_uint16_c:
return typeid(cpp_var) == typeid(dods_uint16*);
case dods_int32_c:
return typeid(cpp_var) == typeid(dods_int32*);
case dods_uint32_c:
return typeid(cpp_var) == typeid(dods_uint32*);
case dods_int64_c:
return typeid(cpp_var) == typeid(dods_int64*);
case dods_uint64_c:
return typeid(cpp_var) == typeid(dods_uint64*);
case dods_float32_c:
return typeid(cpp_var) == typeid(dods_float32*);
case dods_float64_c:
return typeid(cpp_var) == typeid(dods_float64*);
case dods_null_c:
case dods_enum_c:
case dods_str_c:
case dods_url_c:
case dods_opaque_c:
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_group_c:
default:
return false;
}
}
//@{
/** @brief set the value of a byte array */
template <typename T>
bool Vector::set_value_worker(T *v, int sz)
{
if (!v || !types_match(d_proto->type() == dods_enum_c ? static_cast<D4Enum*>(d_proto)->element_type() : d_proto->type(), v))
return false;
m_set_cardinal_values_internal(v, sz);
return true;
}
bool Vector::set_value(dods_byte *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int8 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int16 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_uint16 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int32 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_uint32 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int64 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_uint64 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_float32 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_float64 *val, int sz)
{
return set_value_worker(val, sz);
}
/** @brief set the value of a string or url array */
bool Vector::set_value(string *val, int sz)
{
if ((var()->type() == dods_str_c || var()->type() == dods_url_c) && val) {
d_str.resize(sz);
d_capacity = sz;
for (register int t = 0; t < sz; t++) {
d_str[t] = val[t];
}
set_length(sz);
set_read_p(true);
return true;
}
else {
return false;
}
}
template<typename T>
bool Vector::set_value_worker(vector<T> &v, int sz)
{
return set_value(&v[0], sz);
}
bool Vector::set_value(vector<dods_byte> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int8> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int16> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_uint16> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int32> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_uint32> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int64> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_uint64> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_float32> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_float64> &val, int sz)
{
return set_value_worker(val, sz);
}
/** @brief set the value of a string or url array */
bool Vector::set_value(vector<string> &val, int sz)
{
if (var()->type() == dods_str_c || var()->type() == dods_url_c) {
d_str.resize(sz);
d_capacity = sz;
for (register int t = 0; t < sz; t++) {
d_str[t] = val[t];
}
set_length(sz);
set_read_p(true);
return true;
}
else {
return false;
}
}
//@}
//@{
/** @brief Get a copy of the data held by this variable using the passed subsetIndex
* vector to identify which values to return.
*
* Read data from this variable's internal storage using the passed std::vector
* as an sub-setting index to the values to be returned. For example, if \c subsetIndex
* contains 1,3,5,7 and 9, then 'b' will contain the five values found at indexes
* 1,3, ..., 9.
*
* @note The memory referenced by \c b must point to enough memory to hold index.size()
* bytes; no test for this is performed.
* @note This can only be called for cardinal types.
*
* @param index A std::vector<long> where each value in the vector is the
* location in the Vector's internal storage from which to read the returned value.
* @param b A pointer to the memory to hold the data; must be at least
* length() * sizeof(dods_byte) in size.*/
template <typename T>
void Vector::value_worker(vector<unsigned int> *indices, T *b) const
{
// unsigned long currentIndex;
#if 0
// Iterator version. Not tested, jhrg 8/14/13
for (vector<unsigned int>::iterator i = indices->begin(), e = indices->end(); i != e; ++i) {
unsigned long currentIndex = *i;
if(currentIndex > (unsigned int)length()){
stringstream s;
s << "Vector::value() - Subset index[" << i - subsetIndex->begin() << "] = " << currentIndex << " references a value that is " <<
"outside the bounds of the internal storage [ length()= " << length() << " ] name: '" << name() << "'. ";
throw Error(s.str());
}
b[i - indices->begin()] = reinterpret_cast<T*>(d_buf )[currentIndex];
}
#endif
for (unsigned long i = 0, e = indices->size(); i < e; ++i) {
unsigned long currentIndex = (*indices)[i];
if (currentIndex > (unsigned int)length()) {
stringstream s;
s << "Vector::value() - Subset index[" << i << "] = " << currentIndex << " references a value that is " <<
"outside the bounds of the internal storage [ length()= " << length() << " ] name: '" << name() << "'. ";
throw Error(s.str());
}
b[i] = reinterpret_cast<T*>(d_buf )[currentIndex]; // I like this version - and it works!
}
}
void Vector::value(vector<unsigned int> *indices, dods_byte *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int8 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int16 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_uint16 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int32 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_uint32 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int64 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_uint64 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_float32 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_float64 *b) const { value_worker(indices, b); }
#if 0
template void Vector::value(vector<unsigned int> *indices, dods_byte *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int8 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int16 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_uint16 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int32 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_uint32 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int64 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_uint64 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_float32 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_float64 *b) const;
#endif
/** @brief Get a copy of the data held by this variable using the passed subsetIndex vector to identify which values to return. **/
void Vector::value(vector<unsigned int> *subsetIndex, vector<string> &b) const
{
unsigned long currentIndex;
if (d_proto->type() == dods_str_c || d_proto->type() == dods_url_c){
for(unsigned long i=0; i<subsetIndex->size() ;++i){
currentIndex = (*subsetIndex)[i] ;
if(currentIndex > (unsigned int)length()){
stringstream s;
s << "Vector::value() - Subset index[" << i << "] = " << currentIndex << " references a value that is " <<
"outside the bounds of the internal storage [ length()= " << length() << " ] name: '" << name() << "'. ";
throw Error(s.str());
}
b[i] = d_str[currentIndex];
}
}
}
template <typename T>
void Vector::value_worker(T *v) const
{
// Only copy if v is not null and the proto's type matches.
// For Enums, use the element type since type == dods_enum_c.
if (v && types_match(d_proto->type() == dods_enum_c ? static_cast<D4Enum*>(d_proto)->element_type() : d_proto->type(), v))
memcpy(v, d_buf, length() * sizeof(T));
}
void Vector::value(dods_byte *b) const { value_worker(b); }
void Vector::value(dods_int8 *b) const { value_worker(b); }
void Vector::value(dods_int16 *b) const { value_worker(b); }
void Vector::value(dods_uint16 *b) const { value_worker(b); }
void Vector::value(dods_int32 *b) const { value_worker(b); }
void Vector::value(dods_uint32 *b) const { value_worker(b); }
void Vector::value(dods_int64 *b) const { value_worker(b); }
void Vector::value(dods_uint64 *b) const { value_worker(b); }
void Vector::value(dods_float32 *b) const { value_worker(b); }
void Vector::value(dods_float64 *b) const { value_worker(b); }
#if 0
template void Vector::value(dods_byte *v) const;
template void Vector::value(dods_int8 *v) const;
template void Vector::value(dods_int16 *v) const;
template void Vector::value(dods_uint16 *v) const;
template void Vector::value(dods_int32 *v) const;
template void Vector::value(dods_uint32 *v) const;
template void Vector::value(dods_int64 *v) const;
template void Vector::value(dods_uint64 *v) const;
template void Vector::value(dods_float32 *v) const;
template void Vector::value(dods_float64 *v) const;
#endif
/** @brief Get a copy of the data held by this variable. */
void Vector::value(vector<string> &b) const
{
if (d_proto->type() == dods_str_c || d_proto->type() == dods_url_c)
b = d_str;
}
/** Allocate memory and copy data into the new buffer. Return the new
buffer's pointer. The caller must delete the storage. */
void *Vector::value()
{
void *buffer = new char[width(true)];
memcpy(buffer, d_buf, width(true));
return buffer;
}
//@}
/** @brief Add the BaseType pointer to this constructor type
instance.
Propagate the name of the BaseType instance to this instance. This
ensures that variables at any given level of the DDS table have
unique names (i.e., that Arrays do not have their default name ""). If
<tt>v</tt>'s name is null, then assume that the array \e is named and
don't overwrite it with <tt>v</tt>'s null name.
@note As is the case with Array, this method can be called with a null
BaseType pointer.
@param v The template variable for the array
@param p The Part parameter defaults to nil and is ignored by this method.
*/
void Vector::add_var(BaseType * v, Part /*p*/)
{
#if 0
// Why doesn't this work? tried all 3 variants. jhrg 8/14/13
Vector::add_var_nocopy(v->ptr_duplicate(), p);
add_var_nocopy(v->ptr_duplicate(), p);
add_var_nocopy(v->ptr_duplicate());
#else
// Delete the current template variable
if (d_proto) {
delete d_proto;
d_proto = 0;
}
// if 'v' is null, just set _var to null and exit.
if (!v) {
d_proto = 0;
}
else {
// Jose Garcia
// By getting a copy of this object to be assigned to _var
// we let the owner of 'v' to deallocate it as necessary.
d_proto = v->ptr_duplicate();
// If 'v' has a name, use it as the name of the array. If v doesn't have
// a name, then make sure to copy the array's name to it
// so that software which uses the template's name will still work.
if (!v->name().empty())
set_name(v->name());
else
d_proto->set_name(name());
d_proto->set_parent(this); // Vector --> child
DBG(cerr << "Vector::add_var: Added variable " << v << " ("
<< v->name() << " " << v->type_name() << ")" << endl);
}
#endif
}
void Vector::add_var_nocopy(BaseType * v, Part)
{
// Delete the current template variable
if (d_proto) {
delete d_proto;
d_proto = 0;
}
// if 'v' is null, just set _var to null and exit.
if (!v) {
d_proto = 0;
}
else {
d_proto = v;
// If 'v' has a name, use it as the name of the array. If it *is*
// empty, then make sure to copy the array's name to the template
// so that software which uses the template's name will still work.
if (!v->name().empty())
set_name(v->name());
else
d_proto->set_name(name());
d_proto->set_parent(this); // Vector is the parent; proto is the child
DBG(cerr << "Vector::add_var_no_copy: Added variable " << v << " ("
<< v->name() << " " << v->type_name() << ")" << endl);
}
}
bool Vector::check_semantics(string & msg, bool)
{
return BaseType::check_semantics(msg);
}
/** @brief dumps information about this object
*
* Displays the pointer value of this instance and information about this
* instance.
*
* @param strm C++ i/o stream to dump the information to
* @return void
*/
void Vector::dump(ostream &strm) const
{
strm << DapIndent::LMarg << "Vector::dump - (" << (void *) this << ")" << endl;
DapIndent::Indent();
BaseType::dump(strm);
strm << DapIndent::LMarg << "# elements in vector: " << d_length << endl;
if (d_proto) {
strm << DapIndent::LMarg << "base type:" << endl;
DapIndent::Indent();
d_proto->dump(strm);
DapIndent::UnIndent();
}
else {
strm << DapIndent::LMarg << "base type: not set" << endl;
}
strm << DapIndent::LMarg << "vector contents:" << endl;
DapIndent::Indent();
for (unsigned i = 0; i < d_compound_buf.size(); ++i) {
if (d_compound_buf[i])
d_compound_buf[i]->dump(strm);
else
strm << DapIndent::LMarg << "vec[" << i << "] is null" << endl;
}
DapIndent::UnIndent();
strm << DapIndent::LMarg << "strings:" << endl;
DapIndent::Indent();
for (unsigned i = 0; i < d_str.size(); i++) {
strm << DapIndent::LMarg << d_str[i] << endl;
}
DapIndent::UnIndent();
if (d_buf) {
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c: {
strm << DapIndent::LMarg << "_buf: ";
strm.write(d_buf, d_length);
strm << endl;
}
break;
default: {
strm << DapIndent::LMarg << "_buf: " << (void *) d_buf << endl;
}
break;
}
}
else {
strm << DapIndent::LMarg << "_buf: EMPTY" << endl;
}
DapIndent::UnIndent();
}
} // namespace libdap
CID 81373
// -*- mode: c++; c-basic-offset:4 -*-
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
// (c) COPYRIGHT URI/MIT 1995-1999
// Please read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
// jhrg,jimg James Gallagher <jgallagher@gso.uri.edu>
// Implementation for class Vector. This class is the basis for all the
// vector-type classes in libdap's <Array, List>.
//
// 11/21/95 jhrg
#include "config.h"
#include <cstring>
#include <cassert>
//#define DODS_DEBUG 1
#include <sstream>
#include <vector>
#include <algorithm>
#include <typeinfo>
#include <stdint.h>
#include "crc.h"
#include "Vector.h"
#include "Marshaller.h"
#include "UnMarshaller.h"
#include "D4StreamMarshaller.h"
#include "D4StreamUnMarshaller.h"
#include "D4Enum.h"
#include "Type.h"
#include "dods-datatypes.h"
#include "escaping.h"
#include "util.h"
#include "debug.h"
#include "InternalErr.h"
#undef CLEAR_LOCAL_DATA
using std::cerr;
using std::endl;
namespace libdap {
void Vector::m_duplicate(const Vector & v)
{
d_length = v.d_length;
// _var holds the type of the elements. That is, it holds a BaseType
// which acts as a template for the type of each element.
if (v.d_proto) {
d_proto = v.d_proto->ptr_duplicate(); // use ptr_duplicate()
d_proto->set_parent(this); // ptr_duplicate does not set d_parent.
}
else {
d_proto = 0;
}
// d_compound_buf and d_buf (further down) hold the values of the Vector. The field
// d_compound_buf is used when the Vector holds non-numeric data (including strings
// although it used to be that was not the case jhrg 2/10/05) while d_buf
// holds numeric values.
if (v.d_compound_buf.empty()) {
d_compound_buf = v.d_compound_buf;
}
else {
// Failure to set the size will make the [] operator barf on the LHS
// of the assignment inside the loop.
d_compound_buf.resize(d_length);
for (int i = 0; i < d_length; ++i) {
// There's no need to call set_parent() for each element; we
// maintain the back pointer using the d_proto member. These
// instances are used to hold _values_ only while the d_proto
// field holds the type information for the elements.
d_compound_buf[i] = v.d_compound_buf[i]->ptr_duplicate();
}
}
// copy the strings. This copies the values.
d_str = v.d_str;
// copy numeric values if there are any.
d_buf = 0; // init to null
if (v.d_buf) // only copy if data present
val2buf(v.d_buf); // store v's value in this's _BUF.
d_capacity = v.d_capacity;
}
/**
* @return whether the type of this Vector is a cardinal type
* (i.e., stored in d_buf)
*/
bool Vector::m_is_cardinal_type() const
{
// Not cardinal if no d_proto at all!
if (!d_proto) {
return false;
}
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
// New cardinal types for DAP4
case dods_int8_c:
case dods_uint8_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
return true;
break;
// These must be handled differently.
case dods_str_c:
case dods_url_c:
case dods_opaque_c:
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
return false;
break;
default:
assert("Vector::var: Unrecognized type");
return false;
}
}
/**
* Create _buf so that it can store numElts of the
* (assumed) cardinal type. This create storage for
* width() * numElts bytes.
* If _buf already exists, this DELETES IT and creates a new one.
* So don't use this if you want to keep the original _buf data around.
* This also sets the valueCapacity().
* @param numEltsOfType the number of elements of the cardinal type in var()
that we want storage for.
* @return the size of the buffer created.
* @exception if the Vector's type is not cardinal type.
*/
unsigned int Vector::m_create_cardinal_data_buffer_for_type(unsigned int numEltsOfType)
{
// Make sure we HAVE a _var, or we cannot continue.
if (!d_proto) {
throw InternalErr(__FILE__, __LINE__, "create_cardinal_data_buffer_for_type: Logic error: _var is null!");
}
// Make sure we only do this for the correct data types.
if (!m_is_cardinal_type()) {
throw InternalErr(__FILE__, __LINE__, "create_cardinal_data_buffer_for_type: incorrectly used on Vector whose type was not a cardinal (simple data types).");
}
m_delete_cardinal_data_buffer();
// Actually new up the array with enough bytes to hold numEltsOfType of the actual type.
unsigned int bytesPerElt = d_proto->width();
unsigned int bytesNeeded = bytesPerElt * numEltsOfType;
d_buf = new char[bytesNeeded];
d_capacity = numEltsOfType;
return bytesNeeded;
}
/** Delete d_buf and zero it and d_capacity out */
void Vector::m_delete_cardinal_data_buffer()
{
delete[] d_buf;
d_buf = 0;
d_capacity = 0;
}
/** Helper to reduce cut and paste in the virtual's.
*
*/
template<class CardType>
void Vector::m_set_cardinal_values_internal(const CardType* fromArray, int numElts)
{
if (numElts < 0) {
throw InternalErr(__FILE__, __LINE__, "Logic error: Vector::set_cardinal_values_internal() called with negative numElts!");
}
if (!fromArray) {
throw InternalErr(__FILE__, __LINE__, "Logic error: Vector::set_cardinal_values_internal() called with null fromArray!");
}
set_length(numElts);
m_create_cardinal_data_buffer_for_type(numElts);
memcpy(d_buf, fromArray, numElts * sizeof(CardType));
set_read_p(true);
}
/** The Vector constructor requires the name of the variable to be
created, and a pointer to an object of the type the Vector is to
hold. The name may be omitted, which will create a nameless
variable. The template object may not be omitted.
@param n A string containing the name of the variable to be
created.
@param v A pointer to a prototype for elements.
@param t The type of the resulting Vector object, from the Type
enum list. There is no DAP2 Vector object, so all uses of this
method will be from the Array class. This defaults to
<tt>dods_null_c</tt>.
@see Type
@brief The Vector constructor. */
Vector::Vector(const string & n, BaseType * v, const Type & t, bool is_dap4 /* default:false */) :
BaseType(n, t, is_dap4), d_length(-1), d_proto(0), d_buf(0), d_compound_buf(0), d_capacity(0)
{
if (v)
add_var(v);
DBG2(cerr << "Entering Vector ctor for object: " << this << endl);
if (d_proto)
d_proto->set_parent(this);
}
/** The Vector server-side constructor requires the name of the variable
to be created, the dataset name from which this Vector is created, and
a pointer to an object of the type the Vector is to hold. The
name may be omitted, which will create a nameless variable.
The template object may not be omitted.
@param n A string containing the name of the variable to be
created.
@param d A string containing the dataset name from which the variable is
being created.
@param v A pointer to a prototype for elements.
@param t The type of the resulting Vector object, from the Type
enum list. There is no DAP2 Vector object, so all uses of this
method will be from the Array class. This defaults to
<tt>dods_null_c</tt>.
@see Type
@brief The Vector constructor. */
Vector::Vector(const string & n, const string &d, BaseType * v, const Type & t, bool is_dap4 /* default:false */) :
BaseType(n, d, t, is_dap4), d_length(-1), d_proto(0), d_buf(0), d_compound_buf(0), d_capacity(0)
{
if (v)
add_var(v);
DBG2(cerr << "Entering Vector ctor for object: " << this << endl);
if (d_proto)
d_proto->set_parent(this);
}
/** The Vector copy constructor. */
Vector::Vector(const Vector & rhs) :
BaseType(rhs)
{
DBG2(cerr << "Entering Vector const ctor for object: " << this <<
endl); DBG2(cerr << "RHS: " << &rhs << endl);
m_duplicate(rhs);
}
Vector::~Vector()
{
DBG2(cerr << "Entering ~Vector (" << this << ")" << endl);
delete d_proto;
d_proto = 0;
// Clears all buffers
clear_local_data();
DBG2(cerr << "Exiting ~Vector" << endl);
}
Vector & Vector::operator=(const Vector & rhs)
{
if (this == &rhs)
return *this;
dynamic_cast<BaseType &> (*this) = rhs;
m_duplicate(rhs);
return *this;
}
void Vector::set_name(const std::string& name)
{
BaseType::set_name(name);
// We need to set the prototype name as well since
// this is what gets output in the dds! Otherwise, there's a mismatch.
if (d_proto) {
d_proto->set_name(name);
}
}
int Vector::element_count(bool leaves)
{
if (!leaves)
return 1;
else
return d_proto->element_count(leaves);
// var() only works for simple types!
// jhrg 8/19/13 return var(0)->element_count(leaves);
}
// These mfuncs set the _send_p and _read_p fields of BaseType. They differ
// from BaseType's version in that they set both the Vector object's copy of
// _send_p (_read_p) but also _VAR's copy. This does not matter much when _VAR
// is a scalar, but does matter when it is an aggregate.
/** This function sets the <tt>send_p</tt> flag for both the Vector itself
and its element template. This does not matter much when the
Vector contains simple data types, but does become significant
when the Vector contains compound types.
@brief Indicates that the data is ready to send. */
void Vector::set_send_p(bool state)
{
d_proto->set_send_p(state);
BaseType::set_send_p(state);
}
/** This function sets the <tt>read_p</tt> flag for both the Vector itself
and its element template. This does not matter much when the
Vector contains simple data types, but does become significant
when the Vector contains compound types.
@brief Indicates that the data is ready to send. */
void Vector::set_read_p(bool state)
{
if (d_proto) {
d_proto->set_read_p(state);
}
BaseType::set_read_p(state);
}
/** Returns a copy of the template array element. If the Vector contains
simple data types, the template will contain the value of the last
vector element accessed with the <code>Vector::var(int i)</code> function,
if any. If no such access has been made, or if the Vector contains
compound data types, the value held by the template instance is
undefined.
Note that the parameter <i>exact_match</i> is not used by this mfunc.
@param n The name of the variable to find.
@param exact Unused.
@param s Pointer to a BaseType Pointer Stack. Use this stack to record
the path to the variable. By default this pointer is null, in which case
it is not used.
@return A pointer to the BaseType if found, otherwise null.
@see Vector::var */
BaseType *Vector::var(const string &n, bool exact, btp_stack *s)
{
string name = www2id(n);
DBG2(cerr << "Vector::var: Looking for " << name << endl);
// If this is a Vector of constructor types, look for 'name' recursively.
// Make sure to check for the case where name is the default (the empty
// string). 9/1/98 jhrg
if (d_proto->is_constructor_type()) {
if (name == "" || d_proto->name() == name) {
if (s)
s->push(this);
return d_proto;
}
else {
BaseType * result = d_proto->var(name, exact, s);
if (result && s)
s->push(this);
return result;
}
}
else {
return d_proto;
}
}
/** This version of var(...) searches for <i>name</i> and returns a
pointer to the BaseType object if found. It uses the same search
algorithm as above when <i>exact_match</i> is false. In addition to
returning a pointer to the variable, it pushes onto <i>s</i> a
BaseType pointer to each constructor type that ultimately contains
<i>name</i>.
@param n Find the variable whose name is <i>name</i>.
@param s Record the path to <i>name</i>.
@return A pointer to the named variable. */
BaseType *Vector::var(const string & n, btp_stack & s)
{
string name = www2id(n);
if (d_proto->is_constructor_type())
return d_proto->var(name, s);
else {
s.push((BaseType *) this);
return d_proto;
}
}
/** Returns a pointer to the specified Vector element. The return
pointer will reference the element itself, so multiple calls to this
method should save each value before making the next call.
@param i The index of the desired Vector element. Zero
indicates the first element of the Vector.
@return A pointer to a BaseType class instance containing
the value of the indicated element. The BaseType pointer is locally
maintained and should not be deleted or referenced. Extract the value
right after the method returns.
@see BaseType::var */
BaseType *Vector::var(unsigned int i)
{
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
// Transfer the ith value to the BaseType *d_proto
d_proto->val2buf(d_buf + (i * d_proto->width()));
return d_proto;
break;
case dods_str_c:
case dods_url_c:
d_proto->val2buf(&d_str[i]);
return d_proto;
break;
case dods_opaque_c:
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
return d_compound_buf[i];
break;
default:
throw Error ("Vector::var: Unrecognized type");
break;
}
return 0;
}
/** Returns the number of bytes needed to hold the entire
array. This is equal to \c length() (the number of elements in
in the array) times the width of each
element.
@brief Returns the width of the data, in bytes. */
unsigned int Vector::width(bool constrained) const
{
// Jose Garcia
assert(d_proto);
return length() * d_proto->width(constrained);
}
/** Returns the number of elements in the vector. Note that some
child classes of Vector use the length of -1 as a flag value.
@see Vector::append_dim */
int Vector::length() const
{
return d_length;
}
/** Sets the length of the vector. This function does not allocate
any new space. */
void Vector::set_length(int l)
{
d_length = l;
}
/** Resizes a Vector. If the input length is greater than the
current length of the Vector, new memory is allocated (the
Vector moved if necessary), and the new entries are appended to
the end of the array and padded with Null values. If the input
length is shorter, the tail values are discarded.
@note This method is applicable to the compound types only.
*/
void Vector::vec_resize(int l)
{
// I added this check, which alters the behavior of the method. jhrg 8/14/13
if (m_is_cardinal_type())
throw InternalErr(__FILE__, __LINE__, "Vector::vec_resize() is applicable to compound types only");
d_compound_buf.resize((l > 0) ? l : 0, 0); // Fill with NULLs
d_capacity = l; // capacity in terms of number of elements.
}
/** @brief read data into a variable for later use
Most uses of a variable are to either serialize its data to a stream of
some sort or to read values from some stream and intern those in the
variable for later use. These operations are perform by serialize()
and deserialize() which follow. This function performs essentially both
of these operations without actually using a stream device. The data are
read using the read() method(s) and loaded into the variables directly.
This method is intended to be used by objects which transform DAP objects
like the DataDDS into an ASCII CSV representation.
@note A DAP2-only method
@param eval A reference to a constraint evaluator
@param dds The complete DDS to which this variable belongs */
void Vector::intern_data(ConstraintEvaluator &eval, DDS &dds)
{
DBG(cerr << "Vector::intern_data: " << name() << endl);
if (!read_p())
read(); // read() throws Error and InternalErr
// length() is not capacity; it must be set explicitly in read().
int num = length();
switch (d_proto->type()) {
case dods_byte_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
// For these cases, read() puts the data into d_buf,
// which is what we need.
break;
case dods_str_c:
case dods_url_c:
// For these cases, read() will put the data into d_str[],
// which is also what we need.
break;
case dods_array_c:
// This is an error since there can never be an Array of Array.
throw InternalErr(__FILE__, __LINE__, "Array of Array not supported.");
break;
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
DBG(cerr << "Vector::intern_data: found ctor" << endl);
// For these cases, we need to call read() for each of the 'num'
// elements in the 'd_compound_buf[]' array of BaseType object pointers.
if (d_compound_buf.capacity() == 0)
throw InternalErr(__FILE__, __LINE__, "The capacity of *this* vector is 0.");
for (int i = 0; i < num; ++i)
d_compound_buf[i]->intern_data(eval, dds);
break;
default:
throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
break;
}
}
/** @brief Serialize a Vector.
This uses the Marshaler class to encode each element of a cardinal
array. For Arrays of Str and Url types, send the element count over
as a prefix to the data so that deserialize will know how many elements
to read.
NB: Arrays of cardinal types must already be in BUF (in the local machine's
representation) <i>before</i> this call is made.
*/
bool Vector::serialize(ConstraintEvaluator & eval, DDS & dds, Marshaller &m, bool ce_eval)
{
dds.timeout_on();
if (!read_p())
read(); // read() throws Error and InternalErr
if (ce_eval && !eval.eval_selection(dds, dataset()))
return true;
dds.timeout_off();
// length() is not capacity; it must be set explicitly in read().
int num = length();
bool status = false;
switch (d_proto->type()) {
case dods_byte_c:
m.put_vector(d_buf, num, *this);
status = true;
break;
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
m.put_vector(d_buf, num, d_proto->width(), *this);
status = true;
break;
case dods_str_c:
case dods_url_c:
if (d_str.capacity() == 0)
throw InternalErr(__FILE__, __LINE__, "The capacity of the string vector is 0");
m.put_int(num);
for (int i = 0; i < num; ++i)
m.put_str(d_str[i]);
status = true;
break;
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
//Jose Garcia
// Not setting the capacity of d_compound_buf is an internal error.
if (d_compound_buf.capacity() == 0)
throw InternalErr(__FILE__, __LINE__, "The capacity of *this* vector is 0.");
m.put_int(num);
status = true;
for (int i = 0; i < num && status; ++i)
status = status && d_compound_buf[i]->serialize(eval, dds, m, false);
break;
default:
throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
break;
}
#ifdef CLEAR_LOCAL_DATA
clear_local_data();
#endif
return status;
}
// Read an object from the network and internalize it. For a Vector this is
// handled differently for a `cardinal' type. Vectors of Cardinals are
// stored using the `C' representations because these objects often are used
// to build huge arrays (e.g., an array of 1024 by 1024 bytes). However,
// arrays of non-cardinal types are stored as Vectors of the C++ objects or
// DAP2 objects (Str and Url are vectors of the string class, Structure, ...,
// Grid are vectors of the libdap Structure, ... classes).
//
// The boolean parameter REUSE determines whether internal storage is reused
// or not. If true, the _buf member is assumed to be large enough to hold the
// incoming cardinal data and is *not* reallocated. If false, new storage is
// allocated. If the internal buffer has not yet been allocated, then this
// parameter has no effect (i.e., storage is allocated). This parameter
// effects storage for cardinal data only.
//
// Returns: True is successful, false otherwise.
bool Vector::deserialize(UnMarshaller &um, DDS * dds, bool reuse)
{
unsigned int num;
unsigned i = 0;
switch (d_proto->type()) {
case dods_byte_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_float64_c:
um.get_int((int &) num);
DBG(cerr << "Vector::deserialize: num = " << num << endl);
DBG(cerr << "Vector::deserialize: length = " << length() << endl);
if (length() == -1)
set_length(num);
if (num != (unsigned int) length())
throw InternalErr(__FILE__, __LINE__, "The server sent declarations and data with mismatched sizes for the variable '" + name() + "'.");
if (!d_buf || !reuse) {
// Make d_buf be large enough for length() elements of _var->type()
// m_create...() deletes the old buffer.
m_create_cardinal_data_buffer_for_type(length());
DBG(cerr << "Vector::deserialize: allocating "
<< width() << " bytes for an array of "
<< length() << " " << d_proto->type_name() << endl);
}
if (d_proto->type() == dods_byte_c)
um.get_vector((char **) &d_buf, num, *this);
else
um.get_vector((char **) &d_buf, num, d_proto->width(), *this);
DBG(cerr << "Vector::deserialize: read " << num << " elements\n");
break;
case dods_str_c:
case dods_url_c:
um.get_int((int &) num);
if (length() == -1)
set_length(num);
if (num != (unsigned int) length())
throw InternalErr(__FILE__, __LINE__, "The client sent declarations and data with mismatched sizes.");
d_str.resize((num > 0) ? num : 0); // Fill with NULLs
d_capacity = num; // capacity is number of strings we can fit.
for (i = 0; i < num; ++i) {
string str;
um.get_str(str);
d_str[i] = str;
}
break;
case dods_array_c:
// TODO
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
um.get_int((int &) num);
if (length() == -1)
set_length(num);
if (num != (unsigned int) length())
throw InternalErr(__FILE__, __LINE__, "The client sent declarations and data with mismatched sizes.");
vec_resize(num);
for (i = 0; i < num; ++i) {
d_compound_buf[i] = d_proto->ptr_duplicate();
d_compound_buf[i]->deserialize(um, dds);
}
break;
default:
throw InternalErr(__FILE__, __LINE__, "Unknown type!");
break;
}
return false;
}
void Vector::compute_checksum(Crc32 &checksum)
{
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_float32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_float64_c:
case dods_enum_c:
checksum.AddData(reinterpret_cast<uint8_t*>(d_buf), length() * d_proto->width());
break;
case dods_str_c:
case dods_url_c:
for (int64_t i = 0, e = length(); i < e; ++i)
checksum.AddData(reinterpret_cast<const uint8_t*>(d_str[i].data()), d_str[i].length());
break;
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
d_proto->compute_checksum(checksum);
break;
case dods_array_c: // No array of array
case dods_grid_c: // No grids in DAP4
default:
throw InternalErr(__FILE__, __LINE__, "Unknown or unsupported datatype (" + d_proto->type_name() + ").");
break;
}
}
void Vector::intern_data(Crc32 &checksum/*, DMR &dmr, ConstraintEvaluator &eval*/)
{
if (!read_p())
read(); // read() throws Error and InternalErr
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
case dods_str_c:
case dods_url_c:
compute_checksum(checksum);
break;
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
assert(d_compound_buf.capacity() != 0);
for (int i = 0, e = length(); i < e; ++i)
d_compound_buf[i]->intern_data(checksum/*, dmr, eval*/);
break;
case dods_array_c: // No Array of Array in DAP4 either...
case dods_grid_c:
default:
throw InternalErr(__FILE__, __LINE__, "Unknown or unsupported datatype (" + d_proto->type_name() + ").");
break;
}
}
void
Vector::serialize(D4StreamMarshaller &m, DMR &dmr, /*ConstraintEvaluator &eval,*/ bool filter /*= false*/)
{
if (!read_p())
read(); // read() throws Error and InternalErr
#if 0
if (filter && !eval.eval_selection(dmr, dataset()))
return true;
#endif
int64_t num = length(); // The constrained length in elements
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
m.put_vector(d_buf, num);
break;
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
m.put_vector(d_buf, num, d_proto->width());
break;
case dods_enum_c:
if (d_proto->width() == 1)
m.put_vector(d_buf, num);
else
m.put_vector(d_buf, num, d_proto->width());
break;
case dods_float32_c:
m.put_vector_float32(d_buf, num);
break;
case dods_float64_c:
m.put_vector_float64(d_buf, num);
break;
case dods_str_c:
case dods_url_c:
assert((int64_t)d_str.capacity() >= num);
for (int64_t i = 0; i < num; ++i)
m.put_str(d_str[i]);
break;
case dods_array_c:
throw InternalErr(__FILE__, __LINE__, "Array of Array not allowed.");
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
assert(d_compound_buf.capacity() >= 0);
for (int64_t i = 0; i < num; ++i)
d_compound_buf[i]->serialize(m, dmr, /*eval,*/ filter);
break;
case dods_grid_c:
throw InternalErr(__FILE__, __LINE__, "Grid is not part of DAP4.");
default:
throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
break;
}
#ifdef CLEAR_LOCAL_DATA
clear_local_data();
#endif
}
void
Vector::deserialize(D4StreamUnMarshaller &um, DMR &dmr)
{
if (m_is_cardinal_type()) {
if (d_buf)
m_delete_cardinal_data_buffer();
if (!d_buf)
m_create_cardinal_data_buffer_for_type(length());
}
DBG(cerr << "Vector::deserialize, " << name() << ", length(): " << length() << endl);
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
um.get_vector((char *)d_buf, length());
break;
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
um.get_vector((char *)d_buf, length(), d_proto->width());
break;
case dods_enum_c:
if (d_proto->width() == 1)
um.get_vector((char *)d_buf, length());
else
um.get_vector((char *)d_buf, length(), d_proto->width());
break;
case dods_float32_c:
um.get_vector_float32((char *)d_buf, length());
break;
case dods_float64_c:
um.get_vector_float64((char *)d_buf, length());
break;
case dods_str_c:
case dods_url_c: {
int64_t len = length();
d_str.resize((len > 0) ? len : 0); // Fill with NULLs
d_capacity = len; // capacity is number of strings we can fit.
for (int64_t i = 0; i < len; ++i) {
um.get_str(d_str[i]);
}
break;
}
case dods_array_c:
throw InternalErr(__FILE__, __LINE__, "Array of Array not allowed.");
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c: {
vec_resize(length());
for (int64_t i = 0, end = length(); i < end; ++i) {
d_compound_buf[i] = d_proto->ptr_duplicate();
d_compound_buf[i]->deserialize(um, dmr);
}
break;
}
case dods_grid_c:
throw InternalErr(__FILE__, __LINE__, "Grid is not part of DAP4.");
default:
throw InternalErr(__FILE__, __LINE__, "Unknown type.");
break;
}
}
/** Copies data into the class instance buffer. This function
assumes that the input \e val points to memory which
contains, in row major order, enough elements of the correct
type to fill the array. For an array of a cardinal type the
memory is simply copied in whole into the Vector buffer.
If the variable has already been constrained, this method will load only
number of values/bytes specified by that constraint and will load them
into the 'front' of the object's internal buffer. This is where serialize()
expects to find the data.
For a Vector of Str (OPeNDAP Strings), this assumes \e val points to an
array of C++ strings.
This method should not be used for Structure, Sequence or Grid.
@brief Reads data into the Vector buffer.
@exception InternalErr Thrown if called for Structure, Sequence or
Grid.
@return The number of bytes used by the array.
@param val A pointer to the input data.
@param reuse A boolean value, indicating whether the class
internal data storage can be reused or not. If this argument is
TRUE, the class buffer is assumed to be large enough to hold the
incoming data, and it is <i>not</i> reallocated. If FALSE, new
storage is allocated. If the internal buffer has not been
allocated at all, this argument has no effect. */
unsigned int Vector::val2buf(void *val, bool reuse)
{
// Jose Garcia
// I *think* this method has been mainly designed to be use by read which
// is implemented in the surrogate library. Passing NULL as a pointer to
// this method will be an error of the creator of the surrogate library.
// Even though I recognize the fact that some methods inside libdap++ can
// call val2buf, I think by now no coding bugs such as misusing val2buf
// will be in libdap++, so it will be an internal error from the
// surrogate library.
if (!val)
throw InternalErr(__FILE__, __LINE__, "The incoming pointer does not contain any data.");
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
#if 0
if (d_buf && !reuse)
m_delete_cardinal_data_buffer();
#endif
// First time or no reuse (free'd above)
if (!d_buf || !reuse)
m_create_cardinal_data_buffer_for_type(length());
// width(true) returns the size in bytes given the constraint
memcpy(d_buf, val, width(true));
break;
case dods_str_c:
case dods_url_c:
// Assume val points to an array of C++ string objects. Copy
// them into the vector<string> field of this object.
// Note: d_length is the number of elements in the Vector
d_str.resize(d_length);
d_capacity = d_length;
for (int i = 0; i < d_length; ++i)
d_str[i] = *(static_cast<string *> (val) + i);
break;
default:
throw InternalErr(__FILE__, __LINE__, "Vector::val2buf: bad type");
}
return width(true);
}
/** Copies data from the Vector buffer. This function assumes that
<i>val</i> points to an array large enough to hold N instances of
the `C' representation of the \e numeric element type or C++ string
objects. Never call this method for constructor types Structure,
Sequence or Grid.
When reading data out of a variable that has been constrained, this method
assumes the N values/bytes of constrained data start at the beginning
of the object's internal buffer. For example, do not load an entire
Vector's data using val2buf(), constrain and then use this method to
get the data. Unless your constraint starts with the [0]th element, the
result will not be the correct values.
In the case of a Vector of Str objects, this method will return an array
of C++ std::string objects.
@note It's best to define the pointer to reference the data as
'char *data' and then call this method using '..->buf2val((void**)&data)'.
Then free the storage once you're done using 'delete[] data'. It's not
correct C++ to use 'delete[]' on a void pointer and the allocated memory
\e is an array of char, so 'delete[]' is needed.
@return The number of bytes used to store the array.
@param val A pointer to a pointer to the memory into which the
class data will be copied. If the value pointed to is NULL,
memory will be allocated to hold the data, and the pointer value
modified accordingly. The calling program is responsible for
deallocating the memory indicated by this pointer.
@exception InternalErr Thrown if \e val is null.
@see Vector::set_vec */
unsigned int Vector::buf2val(void **val)
{
// Jose Garcia
// The same comment in Vector::val2buf applies here!
if (!val)
throw InternalErr(__FILE__, __LINE__, "NULL pointer.");
unsigned int wid = static_cast<unsigned int> (width(true /* constrained */));
// This is the width computed using length(). The
// length() property is changed when a projection
// constraint is applied. Thus this is the number of
// bytes in the buffer given the current constraint.
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
if (!d_buf)
throw InternalErr(__FILE__, __LINE__, "Vector::buf2val: Logic error: called when cardinal type data buffer was empty!");
if (!*val)
*val = new char[wid];
memcpy(*val, d_buf, wid);
return wid;
break;
case dods_str_c:
case dods_url_c: {
if (d_str.empty())
throw InternalErr(__FILE__, __LINE__, "Vector::buf2val: Logic error: called when string data buffer was empty!");
if (!*val)
*val = new string[d_length];
for (int i = 0; i < d_length; ++i)
*(static_cast<string *> (*val) + i) = d_str[i];
return width();
break;
}
default:
throw InternalErr(__FILE__, __LINE__, "Vector::buf2val: bad type");
}
//return wid;
}
/** Sets an element of the vector to a given value. If the type of
the input and the type of the Vector do not match, an error
condition is returned.
Use this function only with Vectors containing compound
types. See \c buf2val() or the \c set_value() methods to access
members of Vector containing simple types.
@note This method copies \e val; the caller is responsible for deleting
instance passed as the actual parameter.
@brief Sets element <i>i</i> to value <i>val</i>.
@return void
@exception InternalErr Thrown if \e i is out of range, \e val is null or
there was a type mismatch between the BaseType referenced by \e val and
the \e ith element of this Vector.
@param i The index of the element to be changed.
@param val A pointer to the value to be inserted into the
array.
@see Vector::buf2val */
void Vector::set_vec(unsigned int i, BaseType * val)
{
Vector::set_vec_nocopy(i, val->ptr_duplicate());
}
/** @brief Sets element <i>i</i> to value <i>val</i>.
@note This method does not copy \e val; this class will free the instance
when the variable is deleted or when clear_local_data() is called.
@see Vector::set_vec() */
void Vector::set_vec_nocopy(unsigned int i, BaseType * val)
{
// Jose Garcia
// This is a public method which allows users to set the elements
// of *this* vector. Passing an invalid index, a NULL pointer or
// mismatching the vector type are internal errors.
if (i >= static_cast<unsigned int> (d_length))
throw InternalErr(__FILE__, __LINE__, "Invalid data: index too large.");
if (!val)
throw InternalErr(__FILE__, __LINE__, "Invalid data: null pointer to BaseType object.");
if (val->type() != d_proto->type())
throw InternalErr(__FILE__, __LINE__, "invalid data: type of incoming object does not match *this* vector type.");
if (i >= d_compound_buf.capacity())
vec_resize(i + 10);
d_compound_buf[i] = val;
}
/**
* Remove any read or set data in the private data of this Vector,
* setting read_p() to false.
* Essentially clears the _buf, d_str, and d_compound_buf of any data.
* Useful for tightening up memory when the data is no longer needed,
* but the object cannot yet be destroyed.
*
* On exit: get_value_capacity() == 0 && !read_p()
*/
void Vector::clear_local_data()
{
if (d_buf) {
delete[] d_buf;
d_buf = 0;
}
for (unsigned int i = 0; i < d_compound_buf.size(); ++i) {
delete d_compound_buf[i];
d_compound_buf[i] = 0;
}
// Force memory to be reclaimed.
d_compound_buf.resize(0);
d_str.resize(0);
d_capacity = 0;
set_read_p(false);
}
/**
* Return the capacity of the Vector in terms of number of
* elements of its data type that it can currently hold (i.e. not bytes).
* For example, this could be
* the size of the _buf array in bytes / sizeof(T) for the cardinal
* types T, or the capacity of the d_str vector if T is string or url type.
*/
unsigned int Vector::get_value_capacity() const
{
return d_capacity;
}
/**
* Allocate enough memory for the Vector to contain
* numElements data elements of the Vector's type.
* Must be used before set_value_slice_from_row_major_vector
* to ensure memory exists.
* @param numElements the number of elements of the Vector's type
* to preallocate storage for.
* @exception if the memory cannot be allocated
*/
void Vector::reserve_value_capacity(unsigned int numElements)
{
if (!d_proto) {
throw InternalErr(__FILE__, __LINE__, "reserve_value_capacity: Logic error: _var is null!");
}
switch (d_proto->type()) {
case dods_byte_c:
case dods_char_c:
case dods_int8_c:
case dods_uint8_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c:
// Make _buf be the right size and set _capacity
m_create_cardinal_data_buffer_for_type(numElements);
break;
case dods_str_c:
case dods_url_c:
// Make sure the d_str has enough room for all the strings.
// Technically not needed, but it will speed things up for large arrays.
d_str.reserve(numElements);
d_capacity = numElements;
break;
case dods_array_c:
throw InternalErr(__FILE__, __LINE__, "reserve_value_capacity: Arrays not supported!");
break;
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
// not clear anyone will go this path, but best to be complete.
d_compound_buf.reserve(numElements);
d_capacity = numElements;
break;
default:
throw InternalErr(__FILE__, __LINE__, "reserve_value_capacity: Unknown type!");
break;
} // switch
}
/**
* Make sure there's storage allocated for the current length()
* of the Vector.
* Same as reserveValueCapacity(length())
*/
void Vector::reserve_value_capacity()
{
// Use the current length of the vector as the reserve amount.
reserve_value_capacity(length());
}
/**
* Copy rowMajorData.length() elements currently in a rowMajorData buffer
* into this value buffer starting at element index startElement and
* continuing up to startElement+rowMajorData.length()-1
*
* This is used for aggregating together smaller rowMajor vectors
* into a larger one.
*
* Note: unlike the other set_value calls, this does NOT set read_p()
* since it is assumed to be used as a partial read and the caller
* is expected to set_read_p() when the data is complete.
*
* ASSUMES: rowMajorData.read_p() so that the data is valid!
* ASSUMES: this Vector has enough value_capacity() to contain
* all the elements such that:
* startElement + rowMajorData.length()
* <= this->value_capacity().
* ASSUMES: the data type of this->var() and rowMajorData.var()
* MUST be non-NULL and be the same!
*
* @param rowMajorDataC the vector from which to copy data,
* assumed already read in or set.
* @param startElement the element index
* (NOT byte, but rather data type element)
* to place the first data value.
* @return the number of elements added, such that:
* startElement + the return value is the next "free" element.
*/
unsigned int
Vector::set_value_slice_from_row_major_vector(const Vector& rowMajorDataC, unsigned int startElement)
{
static const string funcName = "set_value_slice_from_row_major_vector:";
// semantically const from the caller's viewpoint, but some calls are not syntactic const.
Vector& rowMajorData = const_cast<Vector&>(rowMajorDataC);
bool typesMatch = rowMajorData.var() && d_proto && (rowMajorData.var()->type() == d_proto->type());
if (!typesMatch) {
throw InternalErr(__FILE__, __LINE__, funcName + "Logic error: types do not match so cannot be copied!");
}
// Make sure the data exists
if (!rowMajorData.read_p()) {
throw InternalErr(__FILE__, __LINE__,
funcName + "Logic error: the Vector to copy data from has !read_p() and should have been read in!");
}
// Check this otherwise the static_cast<unsigned int> below will do the wrong thing.
if (rowMajorData.length() < 0) {
throw InternalErr(__FILE__, __LINE__,
funcName
+ "Logic error: the Vector to copy data from has length() < 0 and was probably not initialized!");
}
// The read-in capacity had better be at least the length (the amount we will copy) or we'll memcpy into bad memory
// I imagine we could copy just the capacity rather than throw, but I really think this implies a problem to be addressed.
if (rowMajorData.get_value_capacity() < static_cast<unsigned int>(rowMajorData.length())) {
throw InternalErr(__FILE__, __LINE__,
funcName
+ "Logic error: the Vector to copy from has a data capacity less than its length, can't copy!");
}
// Make sure there's enough room in this Vector to store all the elements requested. Again,
// better to throw than just copy what we can since it implies a logic error that needs to be solved.
if (d_capacity < (startElement + rowMajorData.length())) {
throw InternalErr(__FILE__, __LINE__,
funcName + "Logic error: the capacity of this Vector cannot hold all the data in the from Vector!");
}
// OK, at this point we're pretty sure we can copy the data, but we have to do it differently depending on type.
switch (d_proto->type()) {
case dods_int8_c:
case dods_uint8_c:
case dods_byte_c:
case dods_char_c:
case dods_int16_c:
case dods_uint16_c:
case dods_int32_c:
case dods_uint32_c:
case dods_int64_c:
case dods_uint64_c:
case dods_enum_c:
case dods_float32_c:
case dods_float64_c: {
if (!d_buf) {
throw InternalErr(__FILE__, __LINE__, funcName + "Logic error: this->_buf was unexpectedly null!");
}
if (!rowMajorData.d_buf) {
throw InternalErr(__FILE__, __LINE__, funcName + "Logic error: rowMajorData._buf was unexpectedly null!");
}
// memcpy the data into this, taking care to do ptr arithmetic on bytes and not sizeof(element)
int varWidth = d_proto->width();
char* pFromBuf = rowMajorData.d_buf;
int numBytesToCopy = rowMajorData.width(true);
char* pIntoBuf = d_buf + (startElement * varWidth);
memcpy(pIntoBuf, pFromBuf, numBytesToCopy);
break;
}
case dods_str_c:
case dods_url_c:
// Strings need to be copied directly
for (unsigned int i = 0; i < static_cast<unsigned int>(rowMajorData.length()); ++i) {
d_str[startElement + i] = rowMajorData.d_str[i];
}
break;
case dods_array_c:
case dods_opaque_c:
case dods_structure_c:
case dods_sequence_c:
case dods_grid_c:
// Not sure that this function will be used for these type of nested objects, so I will throw here.
throw InternalErr(__FILE__, __LINE__,
funcName + "Unimplemented method for Vectors of type: array, opaque, structure, sequence or grid.");
break;
default:
throw InternalErr(__FILE__, __LINE__, funcName + ": Unknown type!");
break;
} // switch (_var->type())
// This is how many elements we copied.
return (unsigned int) rowMajorData.length();
}
/**
* Does the C++ type correspond to the DAP Type enum value? This works only for
* numeric cardinal types. For Enums, pass the value of element_type(); for all
* others use type().
* @param t
* @param dt
* @return True if the types match, false otherwise
*/
template <typename T>
static bool types_match(Type t, T *cpp_var)
{
switch (t) {
case dods_byte_c:
case dods_char_c:
case dods_uint8_c:
return typeid(cpp_var) == typeid(dods_byte*);
case dods_int8_c:
return typeid(cpp_var) == typeid(dods_int8*);
case dods_int16_c:
return typeid(cpp_var) == typeid(dods_int16*);
case dods_uint16_c:
return typeid(cpp_var) == typeid(dods_uint16*);
case dods_int32_c:
return typeid(cpp_var) == typeid(dods_int32*);
case dods_uint32_c:
return typeid(cpp_var) == typeid(dods_uint32*);
case dods_int64_c:
return typeid(cpp_var) == typeid(dods_int64*);
case dods_uint64_c:
return typeid(cpp_var) == typeid(dods_uint64*);
case dods_float32_c:
return typeid(cpp_var) == typeid(dods_float32*);
case dods_float64_c:
return typeid(cpp_var) == typeid(dods_float64*);
case dods_null_c:
case dods_enum_c:
case dods_str_c:
case dods_url_c:
case dods_opaque_c:
case dods_array_c:
case dods_structure_c:
case dods_sequence_c:
case dods_group_c:
default:
return false;
}
}
//@{
/** @brief set the value of a byte array */
template <typename T>
bool Vector::set_value_worker(T *v, int sz)
{
if (!v || !types_match(d_proto->type() == dods_enum_c ? static_cast<D4Enum*>(d_proto)->element_type() : d_proto->type(), v))
return false;
m_set_cardinal_values_internal(v, sz);
return true;
}
bool Vector::set_value(dods_byte *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int8 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int16 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_uint16 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int32 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_uint32 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_int64 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_uint64 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_float32 *val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(dods_float64 *val, int sz)
{
return set_value_worker(val, sz);
}
/** @brief set the value of a string or url array */
bool Vector::set_value(string *val, int sz)
{
if ((var()->type() == dods_str_c || var()->type() == dods_url_c) && val) {
d_str.resize(sz);
d_capacity = sz;
for (register int t = 0; t < sz; t++) {
d_str[t] = val[t];
}
set_length(sz);
set_read_p(true);
return true;
}
else {
return false;
}
}
template<typename T>
bool Vector::set_value_worker(vector<T> &v, int sz)
{
return set_value(&v[0], sz);
}
bool Vector::set_value(vector<dods_byte> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int8> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int16> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_uint16> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int32> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_uint32> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_int64> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_uint64> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_float32> &val, int sz)
{
return set_value_worker(val, sz);
}
bool Vector::set_value(vector<dods_float64> &val, int sz)
{
return set_value_worker(val, sz);
}
/** @brief set the value of a string or url array */
bool Vector::set_value(vector<string> &val, int sz)
{
if (var()->type() == dods_str_c || var()->type() == dods_url_c) {
d_str.resize(sz);
d_capacity = sz;
for (register int t = 0; t < sz; t++) {
d_str[t] = val[t];
}
set_length(sz);
set_read_p(true);
return true;
}
else {
return false;
}
}
//@}
//@{
/** @brief Get a copy of the data held by this variable using the passed subsetIndex
* vector to identify which values to return.
*
* Read data from this variable's internal storage using the passed std::vector
* as an sub-setting index to the values to be returned. For example, if \c subsetIndex
* contains 1,3,5,7 and 9, then 'b' will contain the five values found at indexes
* 1,3, ..., 9.
*
* @note The memory referenced by \c b must point to enough memory to hold index.size()
* bytes; no test for this is performed.
* @note This can only be called for cardinal types.
*
* @param index A std::vector<long> where each value in the vector is the
* location in the Vector's internal storage from which to read the returned value.
* @param b A pointer to the memory to hold the data; must be at least
* length() * sizeof(dods_byte) in size.*/
template <typename T>
void Vector::value_worker(vector<unsigned int> *indices, T *b) const
{
// unsigned long currentIndex;
#if 0
// Iterator version. Not tested, jhrg 8/14/13
for (vector<unsigned int>::iterator i = indices->begin(), e = indices->end(); i != e; ++i) {
unsigned long currentIndex = *i;
if(currentIndex > (unsigned int)length()){
stringstream s;
s << "Vector::value() - Subset index[" << i - subsetIndex->begin() << "] = " << currentIndex << " references a value that is " <<
"outside the bounds of the internal storage [ length()= " << length() << " ] name: '" << name() << "'. ";
throw Error(s.str());
}
b[i - indices->begin()] = reinterpret_cast<T*>(d_buf )[currentIndex];
}
#endif
for (unsigned long i = 0, e = indices->size(); i < e; ++i) {
unsigned long currentIndex = (*indices)[i];
if (currentIndex > (unsigned int)length()) {
stringstream s;
s << "Vector::value() - Subset index[" << i << "] = " << currentIndex << " references a value that is " <<
"outside the bounds of the internal storage [ length()= " << length() << " ] name: '" << name() << "'. ";
throw Error(s.str());
}
b[i] = reinterpret_cast<T*>(d_buf )[currentIndex]; // I like this version - and it works!
}
}
void Vector::value(vector<unsigned int> *indices, dods_byte *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int8 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int16 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_uint16 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int32 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_uint32 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_int64 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_uint64 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_float32 *b) const { value_worker(indices, b); }
void Vector::value(vector<unsigned int> *indices, dods_float64 *b) const { value_worker(indices, b); }
#if 0
template void Vector::value(vector<unsigned int> *indices, dods_byte *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int8 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int16 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_uint16 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int32 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_uint32 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_int64 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_uint64 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_float32 *b) const;
template void Vector::value(vector<unsigned int> *indices, dods_float64 *b) const;
#endif
/** @brief Get a copy of the data held by this variable using the passed subsetIndex vector to identify which values to return. **/
void Vector::value(vector<unsigned int> *subsetIndex, vector<string> &b) const
{
unsigned long currentIndex;
if (d_proto->type() == dods_str_c || d_proto->type() == dods_url_c){
for(unsigned long i=0; i<subsetIndex->size() ;++i){
currentIndex = (*subsetIndex)[i] ;
if(currentIndex > (unsigned int)length()){
stringstream s;
s << "Vector::value() - Subset index[" << i << "] = " << currentIndex << " references a value that is " <<
"outside the bounds of the internal storage [ length()= " << length() << " ] name: '" << name() << "'. ";
throw Error(s.str());
}
b[i] = d_str[currentIndex];
}
}
}
template <typename T>
void Vector::value_worker(T *v) const
{
// Only copy if v is not null and the proto's type matches.
// For Enums, use the element type since type == dods_enum_c.
if (v && types_match(d_proto->type() == dods_enum_c ? static_cast<D4Enum*>(d_proto)->element_type() : d_proto->type(), v))
memcpy(v, d_buf, length() * sizeof(T));
}
void Vector::value(dods_byte *b) const { value_worker(b); }
void Vector::value(dods_int8 *b) const { value_worker(b); }
void Vector::value(dods_int16 *b) const { value_worker(b); }
void Vector::value(dods_uint16 *b) const { value_worker(b); }
void Vector::value(dods_int32 *b) const { value_worker(b); }
void Vector::value(dods_uint32 *b) const { value_worker(b); }
void Vector::value(dods_int64 *b) const { value_worker(b); }
void Vector::value(dods_uint64 *b) const { value_worker(b); }
void Vector::value(dods_float32 *b) const { value_worker(b); }
void Vector::value(dods_float64 *b) const { value_worker(b); }
#if 0
template void Vector::value(dods_byte *v) const;
template void Vector::value(dods_int8 *v) const;
template void Vector::value(dods_int16 *v) const;
template void Vector::value(dods_uint16 *v) const;
template void Vector::value(dods_int32 *v) const;
template void Vector::value(dods_uint32 *v) const;
template void Vector::value(dods_int64 *v) const;
template void Vector::value(dods_uint64 *v) const;
template void Vector::value(dods_float32 *v) const;
template void Vector::value(dods_float64 *v) const;
#endif
/** @brief Get a copy of the data held by this variable. */
void Vector::value(vector<string> &b) const
{
if (d_proto->type() == dods_str_c || d_proto->type() == dods_url_c)
b = d_str;
}
/** Allocate memory and copy data into the new buffer. Return the new
buffer's pointer. The caller must delete the storage. */
void *Vector::value()
{
void *buffer = new char[width(true)];
memcpy(buffer, d_buf, width(true));
return buffer;
}
//@}
/** @brief Add the BaseType pointer to this constructor type
instance.
Propagate the name of the BaseType instance to this instance. This
ensures that variables at any given level of the DDS table have
unique names (i.e., that Arrays do not have their default name ""). If
<tt>v</tt>'s name is null, then assume that the array \e is named and
don't overwrite it with <tt>v</tt>'s null name.
@note As is the case with Array, this method can be called with a null
BaseType pointer.
@param v The template variable for the array
@param p The Part parameter defaults to nil and is ignored by this method.
*/
void Vector::add_var(BaseType * v, Part /*p*/)
{
#if 0
// Why doesn't this work? tried all 3 variants. jhrg 8/14/13
Vector::add_var_nocopy(v->ptr_duplicate(), p);
add_var_nocopy(v->ptr_duplicate(), p);
add_var_nocopy(v->ptr_duplicate());
#else
// Delete the current template variable
if (d_proto) {
delete d_proto;
d_proto = 0;
}
// if 'v' is null, just set _var to null and exit.
if (!v) {
d_proto = 0;
}
else {
// Jose Garcia
// By getting a copy of this object to be assigned to _var
// we let the owner of 'v' to deallocate it as necessary.
d_proto = v->ptr_duplicate();
// If 'v' has a name, use it as the name of the array. If v doesn't have
// a name, then make sure to copy the array's name to it
// so that software which uses the template's name will still work.
if (!v->name().empty())
set_name(v->name());
else
d_proto->set_name(name());
d_proto->set_parent(this); // Vector --> child
DBG(cerr << "Vector::add_var: Added variable " << v << " ("
<< v->name() << " " << v->type_name() << ")" << endl);
}
#endif
}
void Vector::add_var_nocopy(BaseType * v, Part)
{
// Delete the current template variable
if (d_proto) {
delete d_proto;
d_proto = 0;
}
// if 'v' is null, just set _var to null and exit.
if (!v) {
d_proto = 0;
}
else {
d_proto = v;
// If 'v' has a name, use it as the name of the array. If it *is*
// empty, then make sure to copy the array's name to the template
// so that software which uses the template's name will still work.
if (!v->name().empty())
set_name(v->name());
else
d_proto->set_name(name());
d_proto->set_parent(this); // Vector is the parent; proto is the child
DBG(cerr << "Vector::add_var_no_copy: Added variable " << v << " ("
<< v->name() << " " << v->type_name() << ")" << endl);
}
}
bool Vector::check_semantics(string & msg, bool)
{
return BaseType::check_semantics(msg);
}
/** @brief dumps information about this object
*
* Displays the pointer value of this instance and information about this
* instance.
*
* @param strm C++ i/o stream to dump the information to
* @return void
*/
void Vector::dump(ostream &strm) const
{
strm << DapIndent::LMarg << "Vector::dump - (" << (void *) this << ")" << endl;
DapIndent::Indent();
BaseType::dump(strm);
strm << DapIndent::LMarg << "# elements in vector: " << d_length << endl;
if (d_proto) {
strm << DapIndent::LMarg << "base type:" << endl;
DapIndent::Indent();
d_proto->dump(strm);
DapIndent::UnIndent();
}
else {
strm << DapIndent::LMarg << "base type: not set" << endl;
}
strm << DapIndent::LMarg << "vector contents:" << endl;
DapIndent::Indent();
for (unsigned i = 0; i < d_compound_buf.size(); ++i) {
if (d_compound_buf[i])
d_compound_buf[i]->dump(strm);
else
strm << DapIndent::LMarg << "vec[" << i << "] is null" << endl;
}
DapIndent::UnIndent();
strm << DapIndent::LMarg << "strings:" << endl;
DapIndent::Indent();
for (unsigned i = 0; i < d_str.size(); i++) {
strm << DapIndent::LMarg << d_str[i] << endl;
}
DapIndent::UnIndent();
if (d_buf) {
switch (d_proto != 0 ? d_proto->type() : 0) {
case dods_byte_c:
case dods_char_c:
strm << DapIndent::LMarg << "_buf: ";
strm.write(d_buf, d_length);
strm << endl;
break;
case 0:
default:
strm << DapIndent::LMarg << "_buf: " << (void *) d_buf << endl;
break;
}
}
else {
strm << DapIndent::LMarg << "_buf: EMPTY" << endl;
}
DapIndent::UnIndent();
}
} // namespace libdap
|
#include "FPSRole.h"
#include "Engine.h"
#include "Creature.h"
#include "AnimationBlend.h"
#include "WorldEffect.h"
CFPSRole::CFPSRole(void)
{
m_nFire = 0;
m_fAniCoolingTime = 0;
m_fAniNowCoolingTime = 0;
m_fSudCoolingTime = 0;
m_fEmitCoolingTime = 0;
m_fEmitNowCoolingTime = 0;
m_fSudNowCoolingTime = 0;
m_strMuzzleBone = "";
m_pArmsMesh = NULL;
m_pBulletParticle = NULL;
m_strBulletName = "";
m_strMuzzleEffect = "";
}
CFPSRole::~CFPSRole(void)
{
g_Engine.pGame->RemoveNode(m_pBulletParticle);
g_Engine.pGame->RemoveNode(m_pMuzzleEffect);
}
int CFPSRole::Init( int nRoleID,const char* strCharFile )
{
if(CRoleBase::Init(nRoleID,strCharFile))
{
m_pStand[0] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("stand_h");
m_pFire[0] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("fire_h");
m_pStand[1] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("stand_v");
m_pFire[1] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("fire_v");
m_pRun[0] = (CAnimationBlendDual*)m_pCreature->GetAnimationBlend("run_h");
m_pRun[1] = (CAnimationBlendDual*)m_pCreature->GetAnimationBlend("run_v");
m_fAniNowCoolingTime = 0.0f;
m_fAniCoolingTime = 1.0f / m_pFire[0]->GetTriggerSpeed();
m_fEmitNowCoolingTime = 0;
m_fSudNowCoolingTime = 0;
m_fSudCoolingTime = m_fAniCoolingTime * 4.0f; //ֵ
m_fEmitCoolingTime = m_fAniCoolingTime * 3.0f;//ֵ
m_pBulletParticle = (CObjectParticles*)g_Engine.pGame->LoadNode(m_strBulletName);
m_pBulletParticle->GetTracker(TRACKER_CUSTOM)->SetTrackValue(0,0.0f,vec4(1.0f,1.0f,1.0f,0.8f));
m_pBulletParticle->SetName(CUtilStr::Format("%d",m_nRoleID));
m_pMuzzleEffect = (CWorldEffect*)g_Engine.pGame->LoadNode(m_strMuzzleEffect);
m_pMuzzleEffect->Stop();
m_pMuzzleEffect->SetLoop(0);
m_pMuzzleEffect->SetLoopCount(1);
}
return 1;//always return 1;
}
void CFPSRole::OnKeyFrame( _ActionCallback_KeyFrame* pKeyInfo )
{
//I will finish this function later.
}
void CFPSRole::OnActionComplete( _ActionCallback_Complete* pActInfo )
{
return CRoleBase::OnActionComplete(pActInfo);
}
void CFPSRole::SetPaceAnimationF_B( int nF_B )
{
switch(nF_B)
{
case 0:
m_pRun[0]->CloseBlend();
break;
case 1:
m_pRun[0]->PlayAnimationA();
break;
case 2:
m_pRun[0]->PlayAnimationB();
break;
}
}
void CFPSRole::OnFire( float fCoolingTime )
{
}
Signed-off-by: mrlitong <litongtongxue@gmail.com>
#include "FPSRole.h"
#include "Engine.h"
#include "Creature.h"
#include "AnimationBlend.h"
#include "WorldEffect.h"
CFPSRole::CFPSRole(void)
{
m_nFire = 0;
m_fAniCoolingTime = 0;
m_fAniNowCoolingTime = 0;
m_fSudCoolingTime = 0;
m_fEmitCoolingTime = 0;
m_fEmitNowCoolingTime = 0;
m_fSudNowCoolingTime = 0;
m_strMuzzleBone = "";
m_pArmsMesh = NULL;
m_pBulletParticle = NULL;
m_strBulletName = "";
m_strMuzzleEffect = "";
}
CFPSRole::~CFPSRole(void)
{
g_Engine.pGame->RemoveNode(m_pBulletParticle);
g_Engine.pGame->RemoveNode(m_pMuzzleEffect);
}
int CFPSRole::Init( int nRoleID,const char* strCharFile )
{
if(CRoleBase::Init(nRoleID,strCharFile))
{
m_pStand[0] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("stand_h");
m_pFire[0] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("fire_h");
m_pStand[1] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("stand_v");
m_pFire[1] = (CAnimationBlendRotate*)m_pCreature->GetAnimationBlend("fire_v");
m_pRun[0] = (CAnimationBlendDual*)m_pCreature->GetAnimationBlend("run_h");
m_pRun[1] = (CAnimationBlendDual*)m_pCreature->GetAnimationBlend("run_v");
m_fAniNowCoolingTime = 0.0f;
m_fAniCoolingTime = 1.0f / m_pFire[0]->GetTriggerSpeed();
m_fEmitNowCoolingTime = 0;
m_fSudNowCoolingTime = 0;
m_fSudCoolingTime = m_fAniCoolingTime * 4.0f; //ֵ
m_fEmitCoolingTime = m_fAniCoolingTime * 3.0f;//ֵ
m_pBulletParticle = (CObjectParticles*)g_Engine.pGame->LoadNode(m_strBulletName);
m_pBulletParticle->GetTracker(TRACKER_CUSTOM)->SetTrackValue(0,0.0f,vec4(1.0f,1.0f,1.0f,0.8f));
m_pBulletParticle->SetName(CUtilStr::Format("%d",m_nRoleID));
m_pMuzzleEffect = (CWorldEffect*)g_Engine.pGame->LoadNode(m_strMuzzleEffect);
m_pMuzzleEffect->Stop();
m_pMuzzleEffect->SetLoop(0);
m_pMuzzleEffect->SetLoopCount(1);
}
return 1;//always return 1;
}
void CFPSRole::OnKeyFrame( _ActionCallback_KeyFrame* pKeyInfo )
{
//I will finish this function later.
}
void CFPSRole::OnActionComplete( _ActionCallback_Complete* pActInfo )
{
return CRoleBase::OnActionComplete(pActInfo);
}
void CFPSRole::SetPaceAnimationF_B( int nF_B )
{
switch(nF_B)
{
case 0:
m_pRun[0]->CloseBlend();
break;
case 1:
m_pRun[0]->PlayAnimationA();
break;
case 2:
m_pRun[0]->PlayAnimationB();
break;
}
}
void CFPSRole::OnFire( float fCoolingTime )
{
}
void CFPSRole::UpdateMuzzleTransform()
{
m_pFire[0]->LockFrame(2.3f);
m_pFire[1]->LockFrame(2.3f);
m_pStand[0]->LockFrame(2.3f);
m_pStand[1]->LockFrame(2.3f);
} |
/*
* Copyright (c) 2011-2019, The DART development contributors
* All rights reserved.
*
* The list of contributors can be found at:
* https://github.com/dartsim/dart/blob/master/LICENSE
*
* This file is provided under the following "BSD-style" License:
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef DART_COMMON_REQUIRESASPECT_HPP_
#define DART_COMMON_REQUIRESASPECT_HPP_
#include "dart/common/SpecializedForAspect.hpp"
namespace dart {
namespace common {
//==============================================================================
/// RequiresAspect allows classes that inherit Composite to know which Aspects
/// are required for their operation. This guarantees that there is no way for
/// a required Aspect do not get unexpectedly removed from their composite.
///
/// Required Aspects are also automatically specialized for.
template <class... OtherRequiredAspects>
class RequiresAspect
{
};
//==============================================================================
template <class ReqAspect>
class RequiresAspect<ReqAspect> : public virtual SpecializedForAspect<ReqAspect>
{
public:
/// Default constructor. This is where the base Composite is informed that
/// the Aspect type is required.
RequiresAspect();
};
//==============================================================================
template <class ReqAspect1, class... OtherReqAspects>
class RequiresAspect<ReqAspect1, OtherReqAspects...>
: public CompositeJoiner<
Virtual<RequiresAspect<ReqAspect1> >,
Virtual<RequiresAspect<OtherReqAspects...> > >
{
};
} // namespace common
} // namespace dart
#include "dart/common/detail/RequiresAspect.hpp"
#endif // DART_COMMON_REQUIRESASPECT_HPP_
Add missing virtual base class dectoration for RequiresAspect (#1542)
/*
* Copyright (c) 2011-2019, The DART development contributors
* All rights reserved.
*
* The list of contributors can be found at:
* https://github.com/dartsim/dart/blob/master/LICENSE
*
* This file is provided under the following "BSD-style" License:
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef DART_COMMON_REQUIRESASPECT_HPP_
#define DART_COMMON_REQUIRESASPECT_HPP_
#include "dart/common/ClassWithVirtualBase.hpp"
#include "dart/common/SpecializedForAspect.hpp"
namespace dart {
namespace common {
//==============================================================================
/// RequiresAspect allows classes that inherit Composite to know which Aspects
/// are required for their operation. This guarantees that there is no way for
/// a required Aspect do not get unexpectedly removed from their composite.
///
/// Required Aspects are also automatically specialized for.
template <class... OtherRequiredAspects>
class RequiresAspect
{
};
//==============================================================================
DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
template <class ReqAspect>
class RequiresAspect<ReqAspect> : public virtual SpecializedForAspect<ReqAspect>
{
public:
/// Default constructor. This is where the base Composite is informed that
/// the Aspect type is required.
RequiresAspect();
};
DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
//==============================================================================
template <class ReqAspect1, class... OtherReqAspects>
class RequiresAspect<ReqAspect1, OtherReqAspects...>
: public CompositeJoiner<
Virtual<RequiresAspect<ReqAspect1> >,
Virtual<RequiresAspect<OtherReqAspects...> > >
{
};
} // namespace common
} // namespace dart
#include "dart/common/detail/RequiresAspect.hpp"
#endif // DART_COMMON_REQUIRESASPECT_HPP_
|
/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: ConfigurationControllerBroadcaster.hxx,v $
*
* $Revision: 1.2 $
*
* last change: $Author: rt $ $Date: 2007-04-03 15:46:07 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef SD_FRAMEWORK_CONFIGURATION_CONTROLLER_BROADCASTER_HXX
#define SD_FRAMEWORK_CONFIGURATION_CONTROLLER_BROADCASTER_HXX
#ifndef _COM_SUN_STAR_DRAWING_FRAMEWORK_XCONFIGURATIONCHANGELISTENER_HPP_
#include <com/sun/star/drawing/framework/XConfigurationChangeListener.hpp>
#endif
#ifndef _COM_SUN_STAR_DRAWING_FRAMEWORK_XCONFIGURATIONCONTROLLER_HPP_
#include <com/sun/star/drawing/framework/XConfigurationController.hpp>
#endif
#ifndef _COM_SUN_STAR_DRAWING_FRAMEWORK_CONFIGURATIONCHANGEEVENT_HPP_
#include <com/sun/star/drawing/framework/ConfigurationChangeEvent.hpp>
#endif
#include <comphelper/stl_types.hxx>
#include <vector>
#include <hash_map>
namespace sd { namespace framework {
/** This class manages the set of XConfigurationChangeListeners and
calls them when the ConfigurationController wants to broadcast an
event.
For every registered combination of listener and event type a user data
object is stored. This user data object is then given to the listener
whenever it is called for an event. With this the listener can use
a switch statement to handle different event types.
*/
class ConfigurationControllerBroadcaster
{
public:
/** The given controller is used as origin of thrown exceptions.
*/
ConfigurationControllerBroadcaster (
const ::com::sun::star::uno::Reference<
::com::sun::star::drawing::framework::XConfigurationController>& rxController);
/** Add a listener for one type of event. When one listener is
interested in more than one event type this method has to be called
once for every event type. Alternatively it can register as
universal listener that will be called for all event types.
@param rxListener
A valid reference to a listener.
@param rsEventType
The type of event that the listener will be called for. The
empty string is a special value in that the listener will be
called for all event types.
@param rUserData
This object is passed to the listener whenever it is called for
the specified event type. For different event types different
user data objects can be provided.
@throws IllegalArgumentException
when an empty listener reference is given.
*/
void AddListener(
const ::com::sun::star::uno::Reference<
::com::sun::star::drawing::framework::XConfigurationChangeListener>& rxListener,
const ::rtl::OUString& rsEventType,
const ::com::sun::star::uno::Any& rUserData);
/** Remove all references to the given listener. When one listener has
been registered for more than one type of event then it is removed
for all of them.
@param rxListener
A valid reference to a listener.
@throws IllegalArgumentException
when an empty listener reference is given.
*/
void RemoveListener(
const ::com::sun::star::uno::Reference<
::com::sun::star::drawing::framework::XConfigurationChangeListener>& rxListener);
/** Broadcast the given event to all listeners that have been registered
for its type of event as well as all universal listeners.
When calling a listener results in a DisposedException being thrown
the listener is unregistered automatically.
*/
void NotifyListeners (
const ::com::sun::star::drawing::framework::ConfigurationChangeEvent& rEvent);
/** Call all listeners and inform them that the
ConfigurationController is being disposed. When this method returns
the list of registered listeners is empty. Further calls to
RemoveListener() are not necessary but do not result in an error.
*/
void DisposeAndClear (void);
private:
::com::sun::star::uno::Reference<
com::sun::star::drawing::framework::XConfigurationController> mxConfigurationController;
class ListenerDescriptor {public:
::com::sun::star::uno::Reference<
::com::sun::star::drawing::framework::XConfigurationChangeListener> mxListener;
::com::sun::star::uno::Any maUserData;
};
typedef ::std::vector<ListenerDescriptor> ListenerList;
typedef ::std::hash_map
<rtl::OUString,
ListenerList,
::comphelper::UStringHash,
::comphelper::UStringEqual> ListenerMap;
ListenerMap maListenerMap;
/** Broadcast the given event to all listeners in the given list.
When calling a listener results in a DisposedException being thrown
the listener is unregistered automatically.
*/
void NotifyListeners (
const ListenerList& rList,
const ::com::sun::star::drawing::framework::ConfigurationChangeEvent& rEvent);
};
} } // end of namespace sd::framework
#endif
INTEGRATION: CWS presenterview (1.2.22); FILE MERGED
2007/06/18 14:58:38 af 1.2.22.1: #i18486# Added a variant of NotifyListeners.
/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: ConfigurationControllerBroadcaster.hxx,v $
*
* $Revision: 1.3 $
*
* last change: $Author: kz $ $Date: 2008-04-03 13:29:16 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef SD_FRAMEWORK_CONFIGURATION_CONTROLLER_BROADCASTER_HXX
#define SD_FRAMEWORK_CONFIGURATION_CONTROLLER_BROADCASTER_HXX
#include <com/sun/star/drawing/framework/XConfigurationChangeListener.hpp>
#include <com/sun/star/drawing/framework/XConfigurationController.hpp>
#include <com/sun/star/drawing/framework/ConfigurationChangeEvent.hpp>
#include <comphelper/stl_types.hxx>
#include <vector>
#include <hash_map>
namespace css = ::com::sun::star;
namespace sd { namespace framework {
/** This class manages the set of XConfigurationChangeListeners and
calls them when the ConfigurationController wants to broadcast an
event.
For every registered combination of listener and event type a user data
object is stored. This user data object is then given to the listener
whenever it is called for an event. With this the listener can use
a switch statement to handle different event types.
*/
class ConfigurationControllerBroadcaster
{
public:
/** The given controller is used as origin of thrown exceptions.
*/
ConfigurationControllerBroadcaster (
const css::uno::Reference<
css::drawing::framework::XConfigurationController>& rxController);
/** Add a listener for one type of event. When one listener is
interested in more than one event type this method has to be called
once for every event type. Alternatively it can register as
universal listener that will be called for all event types.
@param rxListener
A valid reference to a listener.
@param rsEventType
The type of event that the listener will be called for. The
empty string is a special value in that the listener will be
called for all event types.
@param rUserData
This object is passed to the listener whenever it is called for
the specified event type. For different event types different
user data objects can be provided.
@throws IllegalArgumentException
when an empty listener reference is given.
*/
void AddListener(
const css::uno::Reference<
css::drawing::framework::XConfigurationChangeListener>& rxListener,
const ::rtl::OUString& rsEventType,
const css::uno::Any& rUserData);
/** Remove all references to the given listener. When one listener has
been registered for more than one type of event then it is removed
for all of them.
@param rxListener
A valid reference to a listener.
@throws IllegalArgumentException
when an empty listener reference is given.
*/
void RemoveListener(
const css::uno::Reference<
css::drawing::framework::XConfigurationChangeListener>& rxListener);
/** Broadcast the given event to all listeners that have been registered
for its type of event as well as all universal listeners.
When calling a listener results in a DisposedException being thrown
the listener is unregistered automatically.
*/
void NotifyListeners (
const css::drawing::framework::ConfigurationChangeEvent& rEvent);
/** This convenience variant of NotifyListeners create the event from
the given arguments.
*/
void NotifyListeners (
const ::rtl::OUString& rsEventType,
const ::css::uno::Reference<css::drawing::framework::XResourceId>& rxResourceId,
const ::css::uno::Reference<css::drawing::framework::XResource>& rxResourceObject);
/** Call all listeners and inform them that the
ConfigurationController is being disposed. When this method returns
the list of registered listeners is empty. Further calls to
RemoveListener() are not necessary but do not result in an error.
*/
void DisposeAndClear (void);
private:
css::uno::Reference<
com::sun::star::drawing::framework::XConfigurationController> mxConfigurationController;
class ListenerDescriptor {public:
css::uno::Reference<
css::drawing::framework::XConfigurationChangeListener> mxListener;
css::uno::Any maUserData;
};
typedef ::std::vector<ListenerDescriptor> ListenerList;
typedef ::std::hash_map
<rtl::OUString,
ListenerList,
::comphelper::UStringHash,
::comphelper::UStringEqual> ListenerMap;
ListenerMap maListenerMap;
/** Broadcast the given event to all listeners in the given list.
When calling a listener results in a DisposedException being thrown
the listener is unregistered automatically.
*/
void NotifyListeners (
const ListenerList& rList,
const css::drawing::framework::ConfigurationChangeEvent& rEvent);
};
} } // end of namespace sd::framework
#endif
|
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/globals.h"
#if defined(HOST_OS_FUCHSIA)
#include "vm/virtual_memory.h"
#include <sys/mman.h>
#include <unistd.h>
#include <zircon/process.h>
#include <zircon/status.h>
#include <zircon/syscalls.h>
#include "platform/assert.h"
#include "vm/allocation.h"
#include "vm/growable_array.h"
#include "vm/isolate.h"
#include "vm/lockers.h"
#include "vm/memory_region.h"
#include "vm/os.h"
#include "vm/os_thread.h"
// #define VIRTUAL_MEMORY_LOGGING 1
#if defined(VIRTUAL_MEMORY_LOGGING)
#define LOG_ERR(msg, ...) \
OS::PrintErr("VMVM: %s:%d: " msg, __FILE__, __LINE__, ##__VA_ARGS__)
#define LOG_INFO(msg, ...) \
OS::PrintErr("VMVM: %s:%d: " msg, __FILE__, __LINE__, ##__VA_ARGS__)
#else
#define LOG_ERR(msg, ...)
#define LOG_INFO(msg, ...)
#endif // defined(VIRTUAL_MEMORY_LOGGING)
namespace dart {
DECLARE_FLAG(bool, dual_map_code);
DECLARE_FLAG(bool, write_protect_code);
uword VirtualMemory::page_size_ = 0;
uword VirtualMemory::base_ = 0;
void VirtualMemory::Init() {
page_size_ = getpagesize();
// Cache the base of zx_vmar_root_self() which is used to align mappings.
zx_info_vmar_t buf[1];
size_t actual;
size_t avail;
zx_status_t status =
zx_object_get_info(zx_vmar_root_self(), ZX_INFO_VMAR, buf,
sizeof(zx_info_vmar_t), &actual, &avail);
if (status != ZX_OK) {
FATAL1("zx_object_get_info failed: %s\n", zx_status_get_string(status));
}
base_ = buf[0].base;
}
static void Unmap(zx_handle_t vmar, uword start, uword end) {
ASSERT(start <= end);
const uword size = end - start;
if (size == 0) {
return;
}
zx_status_t status = zx_vmar_unmap(vmar, start, size);
if (status != ZX_OK) {
FATAL1("zx_vmar_unmap failed: %s\n", zx_status_get_string(status));
}
}
static void* MapAligned(zx_handle_t vmar,
zx_handle_t vmo,
zx_vm_option_t options,
uword size,
uword alignment,
uword vmar_base,
uword padded_size) {
// Allocate a larger mapping than needed in order to find a suitable aligned
// mapping within it.
uword base;
zx_status_t status =
zx_vmar_map(vmar, options, 0, vmo, 0u, padded_size, &base);
LOG_INFO("zx_vmar_map(%u, 0x%lx, 0x%lx)\n", options, base, padded_size);
if (status != ZX_OK) {
LOG_ERR("zx_vmar_map(%u, 0x%lx, 0x%lx) failed: %s\n", options, base,
padded_size, zx_status_get_string(status));
return NULL;
}
// Allocate a smaller aligned mapping inside the larger mapping.
const uword orig_base = base;
const uword aligned_base = Utils::RoundUp(base, alignment);
const zx_vm_option_t overwrite_options = options | ZX_VM_SPECIFIC_OVERWRITE;
status = zx_vmar_map(vmar, overwrite_options, aligned_base - vmar_base, vmo,
0u, size, &base);
LOG_INFO("zx_vmar_map(%u, 0x%lx, 0x%lx)\n", overwrite_options,
aligned_base - vmar_base, size);
if (status != ZX_OK) {
LOG_ERR("zx_vmar_map(%u, 0x%lx, 0x%lx) failed: %s\n", overwrite_options,
aligned_base - vmar_base, size, zx_status_get_string(status));
return NULL;
}
ASSERT(base == aligned_base);
// Unmap the unused prefix and suffix. See ZX-3917 and/or ZX-1173.
if (orig_base != base) {
status = zx_vmar_unmap(vmar, orig_base, base - orig_base);
if (status != ZX_OK) {
LOG_ERR("zx_vmar_unmap(0x%lx, 0x%lx) failed: %s\n", orig_base,
base - orig_base, zx_status_get_string(status));
}
}
if ((orig_base + padded_size) != (base + size)) {
status = zx_vmar_unmap(vmar, base + size,
(orig_base + padded_size) - (base + size));
if (status != ZX_OK) {
LOG_ERR("zx_vmar_unmap(0x%lx, 0x%lx) failed: %s\n", base + size,
(orig_base + padded_size) - (base + size),
zx_status_get_string(status));
}
}
return reinterpret_cast<void*>(base);
}
VirtualMemory* VirtualMemory::AllocateAligned(intptr_t size,
intptr_t alignment,
bool is_executable,
const char* name) {
// When FLAG_write_protect_code is active, code memory (indicated by
// is_executable = true) is allocated as non-executable and later
// changed to executable via VirtualMemory::Protect, which requires
// ZX_RIGHT_EXECUTE on the underlying VMO.
// In addition, dual mapping of the same underlying code memory is provided.
const bool dual_mapping =
is_executable && FLAG_write_protect_code && FLAG_dual_map_code;
ASSERT(Utils::IsAligned(size, page_size_));
ASSERT(Utils::IsPowerOfTwo(alignment));
ASSERT(Utils::IsAligned(alignment, page_size_));
const intptr_t padded_size = size + alignment - page_size_;
zx_handle_t vmar = zx_vmar_root_self();
zx_handle_t vmo = ZX_HANDLE_INVALID;
zx_status_t status = zx_vmo_create(size, 0u, &vmo);
if (status != ZX_OK) {
LOG_ERR("zx_vmo_create(0x%lx) failed: %s\n", size,
zx_status_get_string(status));
return NULL;
}
if (name != NULL) {
zx_object_set_property(vmo, ZX_PROP_NAME, name, strlen(name));
}
if (is_executable) {
// Add ZX_RIGHT_EXECUTE permission to VMO, so it can be mapped
// into memory as executable (now or later).
status = zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo);
if (status != ZX_OK) {
LOG_ERR("zx_vmo_replace_as_executable() failed: %s\n",
zx_status_get_string(status));
return NULL;
}
}
const zx_vm_option_t region_options =
ZX_VM_PERM_READ | ZX_VM_PERM_WRITE |
((is_executable && !FLAG_write_protect_code) ? ZX_VM_PERM_EXECUTE : 0);
void* region_ptr = MapAligned(vmar, vmo, region_options, size, alignment,
base_, padded_size);
if (region_ptr == NULL) {
return NULL;
}
MemoryRegion region(region_ptr, size);
VirtualMemory* result;
if (dual_mapping) {
// ZX_VM_PERM_EXECUTE is added later via VirtualMemory::Protect.
const zx_vm_option_t alias_options = ZX_VM_PERM_READ;
void* alias_ptr = MapAligned(vmar, vmo, alias_options, size, alignment,
base_, padded_size);
if (alias_ptr == NULL) {
const uword region_base = reinterpret_cast<uword>(region_ptr);
Unmap(vmar, region_base, region_base + size);
return NULL;
}
ASSERT(region_ptr != alias_ptr);
MemoryRegion alias(alias_ptr, size);
result = new VirtualMemory(region, alias, region);
} else {
result = new VirtualMemory(region, region, region);
}
zx_handle_close(vmo);
return result;
}
VirtualMemory::~VirtualMemory() {
// Reserved region may be empty due to VirtualMemory::Truncate.
if (vm_owns_region() && reserved_.size() != 0) {
Unmap(zx_vmar_root_self(), reserved_.start(), reserved_.end());
LOG_INFO("zx_vmar_unmap(0x%lx, 0x%lx) success\n", reserved_.start(),
reserved_.size());
const intptr_t alias_offset = AliasOffset();
if (alias_offset != 0) {
Unmap(zx_vmar_root_self(), reserved_.start() + alias_offset,
reserved_.end() + alias_offset);
LOG_INFO("zx_vmar_unmap(0x%lx, 0x%lx) success\n",
reserved_.start() + alias_offset, reserved_.size());
}
}
}
void VirtualMemory::FreeSubSegment(void* address, intptr_t size) {
const uword start = reinterpret_cast<uword>(address);
Unmap(zx_vmar_root_self(), start, start + size);
LOG_INFO("zx_vmar_unmap(0x%p, 0x%lx) success\n", address, size);
}
void VirtualMemory::Protect(void* address, intptr_t size, Protection mode) {
#if defined(DEBUG)
Thread* thread = Thread::Current();
ASSERT((thread == nullptr) || thread->IsMutatorThread() ||
thread->isolate()->mutator_thread()->IsAtSafepoint());
#endif
const uword start_address = reinterpret_cast<uword>(address);
const uword end_address = start_address + size;
const uword page_address = Utils::RoundDown(start_address, PageSize());
uint32_t prot = 0;
switch (mode) {
case kNoAccess:
prot = 0;
break;
case kReadOnly:
prot = ZX_VM_PERM_READ;
break;
case kReadWrite:
prot = ZX_VM_PERM_READ | ZX_VM_PERM_WRITE;
break;
case kReadExecute:
prot = ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE;
break;
case kReadWriteExecute:
prot = ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE;
break;
}
zx_status_t status = zx_vmar_protect(zx_vmar_root_self(), prot, page_address,
end_address - page_address);
LOG_INFO("zx_vmar_protect(%u, 0x%lx, 0x%lx)\n", prot, page_address,
end_address - page_address);
if (status != ZX_OK) {
FATAL3("zx_vmar_protect(0x%lx, 0x%lx) failed: %s\n", page_address,
end_address - page_address, zx_status_get_string(status));
}
}
} // namespace dart
#endif // defined(HOST_OS_FUCHSIA)
[fuchsia] Use Unmap() instead of zx_vmar_unmap()
Cleanup from last CL.
Change-Id: I08547b78641867de301d6657c7bc096e7480ad55
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/99243
Reviewed-by: Régis Crelier <c2bf536a10d9f2530c38e4e8da517718be8c39ce@google.com>
Commit-Queue: Zach Anderson <9f8b31e960a68dade71618f1ff6da6e23a1edfc9@google.com>
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/globals.h"
#if defined(HOST_OS_FUCHSIA)
#include "vm/virtual_memory.h"
#include <sys/mman.h>
#include <unistd.h>
#include <zircon/process.h>
#include <zircon/status.h>
#include <zircon/syscalls.h>
#include "platform/assert.h"
#include "vm/allocation.h"
#include "vm/growable_array.h"
#include "vm/isolate.h"
#include "vm/lockers.h"
#include "vm/memory_region.h"
#include "vm/os.h"
#include "vm/os_thread.h"
// #define VIRTUAL_MEMORY_LOGGING 1
#if defined(VIRTUAL_MEMORY_LOGGING)
#define LOG_ERR(msg, ...) \
OS::PrintErr("VMVM: %s:%d: " msg, __FILE__, __LINE__, ##__VA_ARGS__)
#define LOG_INFO(msg, ...) \
OS::PrintErr("VMVM: %s:%d: " msg, __FILE__, __LINE__, ##__VA_ARGS__)
#else
#define LOG_ERR(msg, ...)
#define LOG_INFO(msg, ...)
#endif // defined(VIRTUAL_MEMORY_LOGGING)
namespace dart {
DECLARE_FLAG(bool, dual_map_code);
DECLARE_FLAG(bool, write_protect_code);
uword VirtualMemory::page_size_ = 0;
uword VirtualMemory::base_ = 0;
void VirtualMemory::Init() {
page_size_ = getpagesize();
// Cache the base of zx_vmar_root_self() which is used to align mappings.
zx_info_vmar_t buf[1];
size_t actual;
size_t avail;
zx_status_t status =
zx_object_get_info(zx_vmar_root_self(), ZX_INFO_VMAR, buf,
sizeof(zx_info_vmar_t), &actual, &avail);
if (status != ZX_OK) {
FATAL1("zx_object_get_info failed: %s\n", zx_status_get_string(status));
}
base_ = buf[0].base;
}
static void Unmap(zx_handle_t vmar, uword start, uword end) {
ASSERT(start <= end);
const uword size = end - start;
if (size == 0) {
return;
}
zx_status_t status = zx_vmar_unmap(vmar, start, size);
if (status != ZX_OK) {
FATAL1("zx_vmar_unmap failed: %s\n", zx_status_get_string(status));
}
}
static void* MapAligned(zx_handle_t vmar,
zx_handle_t vmo,
zx_vm_option_t options,
uword size,
uword alignment,
uword vmar_base,
uword padded_size) {
// Allocate a larger mapping than needed in order to find a suitable aligned
// mapping within it.
uword base;
zx_status_t status =
zx_vmar_map(vmar, options, 0, vmo, 0u, padded_size, &base);
LOG_INFO("zx_vmar_map(%u, 0x%lx, 0x%lx)\n", options, base, padded_size);
if (status != ZX_OK) {
LOG_ERR("zx_vmar_map(%u, 0x%lx, 0x%lx) failed: %s\n", options, base,
padded_size, zx_status_get_string(status));
return NULL;
}
// Allocate a smaller aligned mapping inside the larger mapping.
const uword orig_base = base;
const uword aligned_base = Utils::RoundUp(base, alignment);
const zx_vm_option_t overwrite_options = options | ZX_VM_SPECIFIC_OVERWRITE;
status = zx_vmar_map(vmar, overwrite_options, aligned_base - vmar_base, vmo,
0u, size, &base);
LOG_INFO("zx_vmar_map(%u, 0x%lx, 0x%lx)\n", overwrite_options,
aligned_base - vmar_base, size);
if (status != ZX_OK) {
LOG_ERR("zx_vmar_map(%u, 0x%lx, 0x%lx) failed: %s\n", overwrite_options,
aligned_base - vmar_base, size, zx_status_get_string(status));
return NULL;
}
ASSERT(base == aligned_base);
// Unmap the unused prefix and suffix.
Unmap(vmar, orig_base, base);
Unmap(vmar, base + size, orig_base + padded_size);
return reinterpret_cast<void*>(base);
}
VirtualMemory* VirtualMemory::AllocateAligned(intptr_t size,
intptr_t alignment,
bool is_executable,
const char* name) {
// When FLAG_write_protect_code is active, code memory (indicated by
// is_executable = true) is allocated as non-executable and later
// changed to executable via VirtualMemory::Protect, which requires
// ZX_RIGHT_EXECUTE on the underlying VMO.
// In addition, dual mapping of the same underlying code memory is provided.
const bool dual_mapping =
is_executable && FLAG_write_protect_code && FLAG_dual_map_code;
ASSERT(Utils::IsAligned(size, page_size_));
ASSERT(Utils::IsPowerOfTwo(alignment));
ASSERT(Utils::IsAligned(alignment, page_size_));
const intptr_t padded_size = size + alignment - page_size_;
zx_handle_t vmar = zx_vmar_root_self();
zx_handle_t vmo = ZX_HANDLE_INVALID;
zx_status_t status = zx_vmo_create(size, 0u, &vmo);
if (status != ZX_OK) {
LOG_ERR("zx_vmo_create(0x%lx) failed: %s\n", size,
zx_status_get_string(status));
return NULL;
}
if (name != NULL) {
zx_object_set_property(vmo, ZX_PROP_NAME, name, strlen(name));
}
if (is_executable) {
// Add ZX_RIGHT_EXECUTE permission to VMO, so it can be mapped
// into memory as executable (now or later).
status = zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo);
if (status != ZX_OK) {
LOG_ERR("zx_vmo_replace_as_executable() failed: %s\n",
zx_status_get_string(status));
return NULL;
}
}
const zx_vm_option_t region_options =
ZX_VM_PERM_READ | ZX_VM_PERM_WRITE |
((is_executable && !FLAG_write_protect_code) ? ZX_VM_PERM_EXECUTE : 0);
void* region_ptr = MapAligned(vmar, vmo, region_options, size, alignment,
base_, padded_size);
if (region_ptr == NULL) {
return NULL;
}
MemoryRegion region(region_ptr, size);
VirtualMemory* result;
if (dual_mapping) {
// ZX_VM_PERM_EXECUTE is added later via VirtualMemory::Protect.
const zx_vm_option_t alias_options = ZX_VM_PERM_READ;
void* alias_ptr = MapAligned(vmar, vmo, alias_options, size, alignment,
base_, padded_size);
if (alias_ptr == NULL) {
const uword region_base = reinterpret_cast<uword>(region_ptr);
Unmap(vmar, region_base, region_base + size);
return NULL;
}
ASSERT(region_ptr != alias_ptr);
MemoryRegion alias(alias_ptr, size);
result = new VirtualMemory(region, alias, region);
} else {
result = new VirtualMemory(region, region, region);
}
zx_handle_close(vmo);
return result;
}
VirtualMemory::~VirtualMemory() {
// Reserved region may be empty due to VirtualMemory::Truncate.
if (vm_owns_region() && reserved_.size() != 0) {
Unmap(zx_vmar_root_self(), reserved_.start(), reserved_.end());
LOG_INFO("zx_vmar_unmap(0x%lx, 0x%lx) success\n", reserved_.start(),
reserved_.size());
const intptr_t alias_offset = AliasOffset();
if (alias_offset != 0) {
Unmap(zx_vmar_root_self(), reserved_.start() + alias_offset,
reserved_.end() + alias_offset);
LOG_INFO("zx_vmar_unmap(0x%lx, 0x%lx) success\n",
reserved_.start() + alias_offset, reserved_.size());
}
}
}
void VirtualMemory::FreeSubSegment(void* address, intptr_t size) {
const uword start = reinterpret_cast<uword>(address);
Unmap(zx_vmar_root_self(), start, start + size);
LOG_INFO("zx_vmar_unmap(0x%p, 0x%lx) success\n", address, size);
}
void VirtualMemory::Protect(void* address, intptr_t size, Protection mode) {
#if defined(DEBUG)
Thread* thread = Thread::Current();
ASSERT((thread == nullptr) || thread->IsMutatorThread() ||
thread->isolate()->mutator_thread()->IsAtSafepoint());
#endif
const uword start_address = reinterpret_cast<uword>(address);
const uword end_address = start_address + size;
const uword page_address = Utils::RoundDown(start_address, PageSize());
uint32_t prot = 0;
switch (mode) {
case kNoAccess:
prot = 0;
break;
case kReadOnly:
prot = ZX_VM_PERM_READ;
break;
case kReadWrite:
prot = ZX_VM_PERM_READ | ZX_VM_PERM_WRITE;
break;
case kReadExecute:
prot = ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE;
break;
case kReadWriteExecute:
prot = ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE;
break;
}
zx_status_t status = zx_vmar_protect(zx_vmar_root_self(), prot, page_address,
end_address - page_address);
LOG_INFO("zx_vmar_protect(%u, 0x%lx, 0x%lx)\n", prot, page_address,
end_address - page_address);
if (status != ZX_OK) {
FATAL3("zx_vmar_protect(0x%lx, 0x%lx) failed: %s\n", page_address,
end_address - page_address, zx_status_get_string(status));
}
}
} // namespace dart
#endif // defined(HOST_OS_FUCHSIA)
|
#include <iostream>
#include "subprocess.hpp"
#include <cstring>
// Note: this works even for ffmpeg with image2pipe to get err and out stream!
int manual_subprocess(const char* const* cmd)
{
struct subprocess_s process;
if(subprocess_create(cmd, subprocess_option_enable_async | subprocess_option_inherit_environment | subprocess_option_no_window, &process) != 0)
return -1;
int nchars = 128, nerrchars = nchars * 2;
char buf[nchars], errbuf[nerrchars];
memset(buf, '\0', nchars);
memset(errbuf, '\0', nerrchars);
int ret2 = subprocess_read_stderr(&process, errbuf, nerrchars);
if(ret2 == 0)
{
std::cout << "subprocess_read_stderr failure." << std::endl;
return -1;
}
std::cout << "err ret:" << ret2 << std::endl;
std::cout << "errbuf:" << errbuf << std::endl;
int ret = subprocess_read_stdout(&process, buf, nchars); // struct subprocess_s *const process, char *const buffer,unsigned size);
if(ret == 0) // TODO: this handling is missing in struct initialization for SPREAD
{
std::cout << "subprocess_read_stdout failure." << std::endl;
return -1;
}
std::cout << "out ret:" << ret << std::endl;
std::cout << "out buf:" << buf << std::endl;
subprocess_destroy(&process);
return 0;
}
int manual_subprocess_class(const char* const* cmd)
{
Subprocess sp{cmd};
int nchars = 128, nerrchars = nchars * 2;
char buf[nchars], errbuf[nerrchars];
memset(buf, '\0', nchars);
memset(errbuf, '\0', nerrchars);
int ret2 = sp.read_from_stderr(errbuf, nerrchars);
if(ret2 == 0)
{
std::cout << "subprocess_read_stderr completion of process, no data read." << std::endl;
return -1;
}
std::cout << "err ret:" << ret2 << std::endl;
std::cout << "errbuf:" << errbuf << std::endl;
int ret = sp.read_from_stdout(buf, nchars); // struct subprocess_s *const process, char *const buffer,unsigned size);
if(ret == 0) // TODO: this handling is missing in struct initialization for SPREAD
{
std::cout << "subprocess_read_stdout completion of process, no data read." << std::endl;
return -1;
}
std::cout << "out ret:" << ret << std::endl;
std::cout << "out buf:" << buf << std::endl;
return 0;
}
int main(int argc,char** argv)
{
std::cout << "Hello, world" << std::endl;
//const char* cmd[]={"/usr/bin/ffmpeg",0}; // works if don't use errstream
//const char *const cmd[] = {"/usr/bin/ffmpeg", "-v","24","-pix_fmts", 0};
const char* cmd[] = {"/usr/bin/ffmpeg", "-i", "test.mp4", "-pix_fmt", "rgba", "-vcodec", "rawvideo", "-f", "rawvideo", "-", 0};
manual_subprocess_class(cmd);
return 0;
}
Update test_subprocess_oop.cpp
Fixed const requirement for windows.
#include <iostream>
#include "subprocess.hpp"
#include <cstring>
// Note: this works even for ffmpeg with image2pipe to get err and out stream!
int manual_subprocess(const char* const* cmd)
{
struct subprocess_s process;
if(subprocess_create(cmd, subprocess_option_enable_async | subprocess_option_inherit_environment | subprocess_option_no_window, &process) != 0)
return -1;
const int nchars = 128, nerrchars = nchars * 2;
char buf[nchars], errbuf[nerrchars];
memset(buf, '\0', nchars);
memset(errbuf, '\0', nerrchars);
int ret2 = subprocess_read_stderr(&process, errbuf, nerrchars);
if(ret2 == 0)
{
std::cout << "subprocess_read_stderr failure." << std::endl;
return -1;
}
std::cout << "err ret:" << ret2 << std::endl;
std::cout << "errbuf:" << errbuf << std::endl;
int ret = subprocess_read_stdout(&process, buf, nchars); // struct subprocess_s *const process, char *const buffer,unsigned size);
if(ret == 0) // TODO: this handling is missing in struct initialization for SPREAD
{
std::cout << "subprocess_read_stdout failure." << std::endl;
return -1;
}
std::cout << "out ret:" << ret << std::endl;
std::cout << "out buf:" << buf << std::endl;
subprocess_destroy(&process);
return 0;
}
int manual_subprocess_class(const char* const* cmd)
{
Subprocess sp{cmd};
const int nchars = 128, nerrchars = nchars * 2;
char buf[nchars], errbuf[nerrchars];
memset(buf, '\0', nchars);
memset(errbuf, '\0', nerrchars);
int ret2 = sp.read_from_stderr(errbuf, nerrchars);
if(ret2 == 0)
{
std::cout << "subprocess_read_stderr completion of process, no data read." << std::endl;
return -1;
}
std::cout << "err ret:" << ret2 << std::endl;
std::cout << "errbuf:" << errbuf << std::endl;
int ret = sp.read_from_stdout(buf, nchars); // struct subprocess_s *const process, char *const buffer,unsigned size);
if(ret == 0) // TODO: this handling is missing in struct initialization for SPREAD
{
std::cout << "subprocess_read_stdout completion of process, no data read." << std::endl;
return -1;
}
std::cout << "out ret:" << ret << std::endl;
std::cout << "out buf:" << buf << std::endl;
return 0;
}
int main(int argc,char** argv)
{
std::cout << "Hello, world" << std::endl;
//const char* cmd[]={"/usr/bin/ffmpeg",0}; // works if don't use errstream
//const char *const cmd[] = {"/usr/bin/ffmpeg", "-v","24","-pix_fmts", 0};
const char* cmd[] = {"/usr/bin/ffmpeg", "-i", "test.mp4", "-pix_fmt", "rgba", "-vcodec", "rawvideo", "-f", "rawvideo", "-", 0};
manual_subprocess_class(cmd);
return 0;
}
|
/*
* Copyright (C) 2015 Hamburg University of Applied Sciences (HAW)
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @ingroup cpp11-compat
* @{
*
* @file
* @brief C++11 condition variable drop in replacement
*
* @author Raphael Hiesgen <raphael.hiesgen (at) haw-hamburg.de>
*
* @}
*/
#include <cstdio>
#include <stdexcept>
#include <system_error>
#include "irq.h"
#include "sched.h"
#include "vtimer.h"
#include "priority_queue.h"
#include "riot/condition_variable.hpp"
using namespace std::chrono;
namespace riot {
condition_variable::~condition_variable() { m_queue.first = NULL; }
void condition_variable::notify_one() noexcept {
unsigned old_state = disableIRQ();
priority_queue_node_t* head = priority_queue_remove_head(&m_queue);
int other_prio = -1;
if (head != NULL) {
tcb_t* other_thread = (tcb_t*)sched_threads[head->data];
if (other_thread) {
other_prio = other_thread->priority;
sched_set_status(other_thread, STATUS_PENDING);
}
head->data = -1u;
}
restoreIRQ(old_state);
if (other_prio >= 0) {
sched_switch(other_prio);
}
}
void condition_variable::notify_all() noexcept {
unsigned old_state = disableIRQ();
int other_prio = -1;
while (true) {
priority_queue_node_t* head = priority_queue_remove_head(&m_queue);
if (head == NULL) {
break;
}
tcb_t* other_thread = (tcb_t*)sched_threads[head->data];
if (other_thread) {
auto max_prio
= [](int a, int b) { return (a < 0) ? b : ((a < b) ? a : b); };
other_prio = max_prio(other_prio, other_thread->priority);
sched_set_status(other_thread, STATUS_PENDING);
}
head->data = -1u;
}
restoreIRQ(old_state);
if (other_prio >= 0) {
sched_switch(other_prio);
}
}
void condition_variable::wait(unique_lock<mutex>& lock) noexcept {
if (!lock.owns_lock()) {
throw std::system_error(
std::make_error_code(std::errc::operation_not_permitted),
"Mutex not locked.");
}
priority_queue_node_t n;
n.priority = sched_active_thread->priority;
n.data = sched_active_pid;
n.next = NULL;
// the signaling thread may not hold the mutex, the queue is not thread safe
unsigned old_state = disableIRQ();
priority_queue_add(&m_queue, &n);
restoreIRQ(old_state);
mutex_unlock_and_sleep(lock.mutex()->native_handle());
if (n.data != -1u) {
// on signaling n.data is set to -1u
// if it isn't set, then the wakeup is either spurious or a timer wakeup
old_state = disableIRQ();
priority_queue_remove(&m_queue, &n);
restoreIRQ(old_state);
}
mutex_lock(lock.mutex()->native_handle());
}
cv_status condition_variable::wait_until(unique_lock<mutex>& lock,
const time_point& timeout_time) {
vtimer_t timer;
// todo: use function to wait for absolute timepoint once available
timex_t before;
vtimer_now(&before);
auto diff = timex_sub(timeout_time.native_handle(), before);
vtimer_set_wakeup(&timer, diff, sched_active_pid);
wait(lock);
timex_t after;
vtimer_now(&after);
vtimer_remove(&timer);
auto cmp = timex_cmp(after, timeout_time.native_handle());
return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
}
} // namespace riot
sys/cpp11-compat: condition variable: fix includes
/*
* Copyright (C) 2015 Hamburg University of Applied Sciences (HAW)
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @ingroup cpp11-compat
* @{
*
* @file
* @brief C++11 condition variable drop in replacement
*
* @author Raphael Hiesgen <raphael.hiesgen (at) haw-hamburg.de>
*
* @}
*/
#include <stdexcept>
#include <system_error>
#include "irq.h"
#include "sched.h"
#include "timex.h"
#include "vtimer.h"
#include "priority_queue.h"
#include "riot/condition_variable.hpp"
using namespace std::chrono;
namespace riot {
condition_variable::~condition_variable() { m_queue.first = NULL; }
void condition_variable::notify_one() noexcept {
unsigned old_state = disableIRQ();
priority_queue_node_t* head = priority_queue_remove_head(&m_queue);
int other_prio = -1;
if (head != NULL) {
tcb_t* other_thread = (tcb_t*)sched_threads[head->data];
if (other_thread) {
other_prio = other_thread->priority;
sched_set_status(other_thread, STATUS_PENDING);
}
head->data = -1u;
}
restoreIRQ(old_state);
if (other_prio >= 0) {
sched_switch(other_prio);
}
}
void condition_variable::notify_all() noexcept {
unsigned old_state = disableIRQ();
int other_prio = -1;
while (true) {
priority_queue_node_t* head = priority_queue_remove_head(&m_queue);
if (head == NULL) {
break;
}
tcb_t* other_thread = (tcb_t*)sched_threads[head->data];
if (other_thread) {
auto max_prio
= [](int a, int b) { return (a < 0) ? b : ((a < b) ? a : b); };
other_prio = max_prio(other_prio, other_thread->priority);
sched_set_status(other_thread, STATUS_PENDING);
}
head->data = -1u;
}
restoreIRQ(old_state);
if (other_prio >= 0) {
sched_switch(other_prio);
}
}
void condition_variable::wait(unique_lock<mutex>& lock) noexcept {
if (!lock.owns_lock()) {
throw std::system_error(
std::make_error_code(std::errc::operation_not_permitted),
"Mutex not locked.");
}
priority_queue_node_t n;
n.priority = sched_active_thread->priority;
n.data = sched_active_pid;
n.next = NULL;
// the signaling thread may not hold the mutex, the queue is not thread safe
unsigned old_state = disableIRQ();
priority_queue_add(&m_queue, &n);
restoreIRQ(old_state);
mutex_unlock_and_sleep(lock.mutex()->native_handle());
if (n.data != -1u) {
// on signaling n.data is set to -1u
// if it isn't set, then the wakeup is either spurious or a timer wakeup
old_state = disableIRQ();
priority_queue_remove(&m_queue, &n);
restoreIRQ(old_state);
}
mutex_lock(lock.mutex()->native_handle());
}
cv_status condition_variable::wait_until(unique_lock<mutex>& lock,
const time_point& timeout_time) {
vtimer_t timer;
// todo: use function to wait for absolute timepoint once available
timex_t before;
vtimer_now(&before);
auto diff = timex_sub(timeout_time.native_handle(), before);
vtimer_set_wakeup(&timer, diff, sched_active_pid);
wait(lock);
timex_t after;
vtimer_now(&after);
vtimer_remove(&timer);
auto cmp = timex_cmp(after, timeout_time.native_handle());
return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
}
} // namespace riot
|
#include <iostream>
#include <cstring>
#include "RTOSCListener.h"
#include "oscpack/osc/OscReceivedElements.h"
#include "oscpack/osc/OscPacketListener.h"
#include "oscpack/ip/UdpSocket.h"
#include "rtcmix_parse.h"
int parse_score_buffer(const char *buffer, int buflen);
void RTOSCListener::ProcessMessage(const osc::ReceivedMessage& m,
const IpEndpointName& remoteEndpoint){
(void) remoteEndpoint; // suppress unused parameter warning
int status;
if(std::strcmp(m.AddressPattern(), "/RTcmix/ScoreCommands") == 0){
osc::ReceivedMessageArgumentStream args = m.ArgumentStream();
const char *rtScript;
args >> rtScript >> osc::EndMessage;
std::cout << rtScript << std::endl;
status = parse_score_buffer(rtScript, std::strlen(rtScript));
}
}
Added print message on receiving script from osc server
#include <iostream>
#include <cstring>
#include "RTOSCListener.h"
#include "oscpack/osc/OscReceivedElements.h"
#include "oscpack/osc/OscPacketListener.h"
#include "oscpack/ip/UdpSocket.h"
#include "rtcmix_parse.h"
int parse_score_buffer(const char *buffer, int buflen);
void RTOSCListener::ProcessMessage(const osc::ReceivedMessage& m,
const IpEndpointName& remoteEndpoint){
(void) remoteEndpoint; // suppress unused parameter warning
int status;
if(std::strcmp(m.AddressPattern(), "/RTcmix/ScoreCommands") == 0){
osc::ReceivedMessageArgumentStream args = m.ArgumentStream();
const char *rtScript;
args >> rtScript >> osc::EndMessage;
std::cout << "<<< OSC Server Recieved Script >>>" << std::endl;
std::cout << rtScript << std::endl;
status = parse_score_buffer(rtScript, std::strlen(rtScript));
}
}
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "xwalk/application/common/application_manifest_constants.h"
namespace xwalk {
namespace application_manifest_keys {
const char kAppKey[] = "app";
const char kAppMainKey[] = "app.main";
const char kAppMainScriptsKey[] = "app.main.scripts";
const char kAppMainSourceKey[] = "app.main.source";
const char kCSPKey[] = "content_security_policy";
const char kDescriptionKey[] = "description";
const char kDisplay[] = "display";
const char kLaunchLocalPathKey[] = "app.launch.local_path";
const char kLaunchScreen[] = "launch_screen";
const char kLaunchScreenDefault[] = "launch_screen.default";
const char kLaunchScreenImageBorderDefault[] =
"launch_screen.default.image_border";
const char kLaunchScreenImageBorderLandscape[] =
"launch_screen.landscape.image_border";
const char kLaunchScreenImageBorderPortrait[] =
"launch_screen.portrait.image_border";
const char kLaunchScreenLandscape[] = "launch_screen.landscape";
const char kLaunchScreenPortrait[] = "launch_screen.portrait";
const char kLaunchScreenReadyWhen[] = "launch_screen.ready_when";
const char kLaunchWebURLKey[] = "app.launch.web_url";
const char kManifestVersionKey[] = "manifest_version";
const char kNameKey[] = "name";
const char kPermissionsKey[] = "permissions";
const char kURLKey[] = "url";
const char kVersionKey[] = "version";
const char kWebURLsKey[] = "app.urls";
const char kXWalkHostsKey[] = "xwalk_hosts";
#if defined(OS_TIZEN)
const char kTizenAppIdKey[] = "tizen_app_id";
const char kIcon128Key[] = "icons.128";
#endif
} // namespace application_manifest_keys
// manifest keys for widget applications.
namespace application_widget_keys {
const char kNamespaceKey[] = "@namespace";
const char kXmlLangKey[] = "@lang";
const char kDefaultLocaleKey[] = "widget.@defaultlocale";
const char kNameKey[] = "widget.name.#text";
const char kVersionKey[] = "widget.@version";
const char kWidgetKey[] = "widget";
const char kLaunchLocalPathKey[] = "widget.content.@src";
const char kWebURLsKey[] = "widget.@id";
const char kAuthorKey[] = "widget.author.#text";
const char kDescriptionKey[] = "widget.description.#text";
const char kShortNameKey[] = "widget.name.@short";
const char kIDKey[] = "widget.@id";
const char kAuthorEmailKey[] = "widget.author.@email";
const char kAuthorHrefKey[] = "widget.author.@href";
const char kHeightKey[] = "widget.@height";
const char kWidthKey[] = "widget.@width";
const char kPreferencesKey[] = "widget.preference";
const char kCSPKey[] = "widget.content-security-policy.#text";
const char kAccessKey[] = "widget.access";
// Child keys inside 'kPreferencesKey'.
const char kPreferencesNameKey[] = "@name";
const char kPreferencesValueKey[] = "@value";
const char kPreferencesReadonlyKey[] = "@readonly";
// Child keys inside 'kAccessKey'.
const char kAccessOriginKey[] = "@origin";
const char kAccessSubdomainsKey[] = "@subdomains";
#if defined(OS_TIZEN)
const char kIcon128Key[] = "widget.icon.@src";
const char kTizenApplicationKey[] = "widget.application";
// Child keys inside 'kTizenApplicationKey'
const char kTizenApplicationIdKey[] = "@id";
const char kTizenApplicationPackageKey[] = "@package";
const char kTizenApplicationRequiredVersionKey[] = "@required_version";
const char kTizenAppIdKey[] = "widget.application.@package";
const char kAllowNavigationKey[] = "widget.allow-navigation.#text";
const char kCSPReportOnlyKey[] =
"widget.content-security-policy-report-only.#text";
const char kTizenSettingKey[] = "widget.setting";
const char kTizenHardwareKey[] = "widget.setting.@hwkey";
const char kTizenMetaDataKey[] = "widget.metadata";
// Child keys inside 'kTizenMetaDataKey'
const char kTizenMetaDataNameKey[] = "@key";
const char kTizenMetaDataValueKey[] = "@value";
#endif
} // namespace application_widget_keys
#if defined(OS_TIZEN)
const char kTizenNamespacePrefix[] = "http://tizen.org/ns/widgets";
#endif
namespace application_manifest_errors {
const char kInvalidDescription[] =
"Invalid value for 'description'.";
const char kInvalidKey[] =
"Value 'key' is missing or invalid.";
const char kInvalidManifestVersion[] =
"Invalid value for 'manifest_version'. Must be an integer greater than "
"zero.";
const char kInvalidName[] =
"Required value 'name' is missing or invalid.";
const char kInvalidVersion[] =
"Required value 'version' is missing or invalid. It must be between 1-4 "
"dot-separated integers each between 0 and 65536.";
const char kManifestParseError[] =
"Manifest is not valid JSON.";
const char kManifestUnreadable[] =
"Manifest file is missing or unreadable.";
const char kPlatformAppNeedsManifestVersion2[] =
"Packaged apps need manifest_version set to >= 2";
} // namespace application_manifest_errors
namespace application {
const char* GetNameKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kNameKey;
return application_manifest_keys::kNameKey;
}
const char* GetVersionKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kVersionKey;
return application_manifest_keys::kVersionKey;
}
const char* GetWebURLsKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kWebURLsKey;
return application_manifest_keys::kWebURLsKey;
}
const char* GetLaunchLocalPathKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kLaunchLocalPathKey;
return application_manifest_keys::kLaunchLocalPathKey;
}
const char* GetCSPKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kCSPKey;
return application_manifest_keys::kCSPKey;
}
#if defined(OS_TIZEN)
const char* GetTizenAppIdKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kTizenAppIdKey;
return application_manifest_keys::kTizenAppIdKey;
}
const char* GetIcon128Key(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kIcon128Key;
return application_manifest_keys::kIcon128Key;
}
#endif
} // namespace application
} // namespace xwalk
[Tizen][Runtime] Fix using the wrong attribute name for hardware key setting.
In Tizen, the <tizen:setting hwkey-event="disable" /> setting could
disable the hardware key event. But the implementation use the wrong
attribute name "hwkey", need to change it to "hwkey-event" according to
Tizen core spec feature XWALK-1491.
BUG=XWALK-1611
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "xwalk/application/common/application_manifest_constants.h"
namespace xwalk {
namespace application_manifest_keys {
const char kAppKey[] = "app";
const char kAppMainKey[] = "app.main";
const char kAppMainScriptsKey[] = "app.main.scripts";
const char kAppMainSourceKey[] = "app.main.source";
const char kCSPKey[] = "content_security_policy";
const char kDescriptionKey[] = "description";
const char kDisplay[] = "display";
const char kLaunchLocalPathKey[] = "app.launch.local_path";
const char kLaunchScreen[] = "launch_screen";
const char kLaunchScreenDefault[] = "launch_screen.default";
const char kLaunchScreenImageBorderDefault[] =
"launch_screen.default.image_border";
const char kLaunchScreenImageBorderLandscape[] =
"launch_screen.landscape.image_border";
const char kLaunchScreenImageBorderPortrait[] =
"launch_screen.portrait.image_border";
const char kLaunchScreenLandscape[] = "launch_screen.landscape";
const char kLaunchScreenPortrait[] = "launch_screen.portrait";
const char kLaunchScreenReadyWhen[] = "launch_screen.ready_when";
const char kLaunchWebURLKey[] = "app.launch.web_url";
const char kManifestVersionKey[] = "manifest_version";
const char kNameKey[] = "name";
const char kPermissionsKey[] = "permissions";
const char kURLKey[] = "url";
const char kVersionKey[] = "version";
const char kWebURLsKey[] = "app.urls";
const char kXWalkHostsKey[] = "xwalk_hosts";
#if defined(OS_TIZEN)
const char kTizenAppIdKey[] = "tizen_app_id";
const char kIcon128Key[] = "icons.128";
#endif
} // namespace application_manifest_keys
// manifest keys for widget applications.
namespace application_widget_keys {
const char kNamespaceKey[] = "@namespace";
const char kXmlLangKey[] = "@lang";
const char kDefaultLocaleKey[] = "widget.@defaultlocale";
const char kNameKey[] = "widget.name.#text";
const char kVersionKey[] = "widget.@version";
const char kWidgetKey[] = "widget";
const char kLaunchLocalPathKey[] = "widget.content.@src";
const char kWebURLsKey[] = "widget.@id";
const char kAuthorKey[] = "widget.author.#text";
const char kDescriptionKey[] = "widget.description.#text";
const char kShortNameKey[] = "widget.name.@short";
const char kIDKey[] = "widget.@id";
const char kAuthorEmailKey[] = "widget.author.@email";
const char kAuthorHrefKey[] = "widget.author.@href";
const char kHeightKey[] = "widget.@height";
const char kWidthKey[] = "widget.@width";
const char kPreferencesKey[] = "widget.preference";
const char kCSPKey[] = "widget.content-security-policy.#text";
const char kAccessKey[] = "widget.access";
// Child keys inside 'kPreferencesKey'.
const char kPreferencesNameKey[] = "@name";
const char kPreferencesValueKey[] = "@value";
const char kPreferencesReadonlyKey[] = "@readonly";
// Child keys inside 'kAccessKey'.
const char kAccessOriginKey[] = "@origin";
const char kAccessSubdomainsKey[] = "@subdomains";
#if defined(OS_TIZEN)
const char kIcon128Key[] = "widget.icon.@src";
const char kTizenApplicationKey[] = "widget.application";
// Child keys inside 'kTizenApplicationKey'
const char kTizenApplicationIdKey[] = "@id";
const char kTizenApplicationPackageKey[] = "@package";
const char kTizenApplicationRequiredVersionKey[] = "@required_version";
const char kTizenAppIdKey[] = "widget.application.@package";
const char kAllowNavigationKey[] = "widget.allow-navigation.#text";
const char kCSPReportOnlyKey[] =
"widget.content-security-policy-report-only.#text";
const char kTizenSettingKey[] = "widget.setting";
const char kTizenHardwareKey[] = "widget.setting.@hwkey-event";
const char kTizenMetaDataKey[] = "widget.metadata";
// Child keys inside 'kTizenMetaDataKey'
const char kTizenMetaDataNameKey[] = "@key";
const char kTizenMetaDataValueKey[] = "@value";
#endif
} // namespace application_widget_keys
#if defined(OS_TIZEN)
const char kTizenNamespacePrefix[] = "http://tizen.org/ns/widgets";
#endif
namespace application_manifest_errors {
const char kInvalidDescription[] =
"Invalid value for 'description'.";
const char kInvalidKey[] =
"Value 'key' is missing or invalid.";
const char kInvalidManifestVersion[] =
"Invalid value for 'manifest_version'. Must be an integer greater than "
"zero.";
const char kInvalidName[] =
"Required value 'name' is missing or invalid.";
const char kInvalidVersion[] =
"Required value 'version' is missing or invalid. It must be between 1-4 "
"dot-separated integers each between 0 and 65536.";
const char kManifestParseError[] =
"Manifest is not valid JSON.";
const char kManifestUnreadable[] =
"Manifest file is missing or unreadable.";
const char kPlatformAppNeedsManifestVersion2[] =
"Packaged apps need manifest_version set to >= 2";
} // namespace application_manifest_errors
namespace application {
const char* GetNameKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kNameKey;
return application_manifest_keys::kNameKey;
}
const char* GetVersionKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kVersionKey;
return application_manifest_keys::kVersionKey;
}
const char* GetWebURLsKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kWebURLsKey;
return application_manifest_keys::kWebURLsKey;
}
const char* GetLaunchLocalPathKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kLaunchLocalPathKey;
return application_manifest_keys::kLaunchLocalPathKey;
}
const char* GetCSPKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kCSPKey;
return application_manifest_keys::kCSPKey;
}
#if defined(OS_TIZEN)
const char* GetTizenAppIdKey(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kTizenAppIdKey;
return application_manifest_keys::kTizenAppIdKey;
}
const char* GetIcon128Key(Manifest::PackageType package_type) {
if (package_type == Manifest::TYPE_WGT)
return application_widget_keys::kIcon128Key;
return application_manifest_keys::kIcon128Key;
}
#endif
} // namespace application
} // namespace xwalk
|
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#include <OpenThreads/ScopedLock>
#include <osg/ImageSequence>
#include <osg/Notify>
#include <osg/Camera>
#include <osg/NodeVisitor>
#include <osg/Texture2D>
#include <math.h>
using namespace osg;
void ImageSequence::UpdateCallback::operator () (osg::StateAttribute* attr, osg::NodeVisitor* nv)
{
osg::Texture* texture = attr ? attr->asTexture() : 0;
// osg::notify(osg::NOTICE)<<"ImageSequence::UpdateCallback::"<<texture<<std::endl;
if (texture)
{
for(unsigned int i=0; i<texture->getNumImages(); ++i)
{
texture->getImage(i)->update(nv);
}
}
}
ImageSequence::ImageSequence()
{
_referenceTime = DBL_MAX;
_timeMultiplier = 1.0;
_mode = PRE_LOAD_ALL_IMAGES;
_length = 1.0;
_timePerImage = 1.0;
_fileNamesIterator = _fileNames.end();
_fileNamesIteratorTime = 0.0;
_imageIterator = _images.end();
_imageIteratorTime = 0.0;
_seekTime = 0.0;
_seekTimeSet = false;
}
ImageSequence::ImageSequence(const ImageSequence& is,const CopyOp& copyop):
osg::ImageStream(is,copyop),
_referenceTime(is._referenceTime),
_timeMultiplier(is._timeMultiplier),
_mode(is._mode),
_length(is._length),
_timePerImage(is._timePerImage)
{
_fileNamesIterator = _fileNames.end();
_fileNamesIteratorTime = 0.0;
_imageIterator = _images.end();
_imageIteratorTime = 0.0;
_seekTime = is._seekTime;
_seekTimeSet = is._seekTimeSet;
}
int ImageSequence::compare(const Image& rhs) const
{
return ImageStream::compare(rhs);
}
void ImageSequence::seek(double time)
{
_seekTime = time;
_seekTimeSet = true;
}
void ImageSequence::play()
{
_status=PLAYING;
}
void ImageSequence::pause()
{
_status=PAUSED;
}
void ImageSequence::rewind()
{
seek(0.0f);
}
void ImageSequence::setMode(Mode mode)
{
_mode = mode;
}
void ImageSequence::setLength(double length)
{
_length = length;
computeTimePerImage();
}
void ImageSequence::computeTimePerImage()
{
if (!_fileNames.empty()) _timePerImage = _length / double(_fileNames.size());
else if (!_images.empty()) _timePerImage = _length / double(_images.size());
else _timePerImage = _length;
}
void ImageSequence::addImageFile(const std::string& fileName)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
_fileNames.push_back(fileName);
computeTimePerImage();
if (_fileNamesIterator==_fileNames.end())
{
_fileNamesIterator = _fileNames.begin();
_fileNamesIteratorTime = _referenceTime;
}
}
void ImageSequence::addImage(osg::Image* image)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
if (!_filesRequested.empty())
{
// follows is a mechanism that ensures that requested images
// get merged in the correct time order.
if (_filesRequested.front().first != image->getFileName())
{
for(FileNameImageList::iterator itr = _filesRequested.begin();
itr != _filesRequested.end();
++itr)
{
if (itr->first == image->getFileName())
{
osg::notify(osg::NOTICE)<<"inserting image into waiting stake : "<<image->getFileName()<<std::endl;
itr->second = image;
return;
}
}
// osg::notify(osg::NOTICE)<<"image not expected : "<<image->getFileName()<<std::endl;
_images.push_back(image);
}
else
{
// osg::notify(osg::NOTICE)<<"merging image in order expected : "<<image->getFileName()<<std::endl;
_images.push_back(image);
_filesRequested.pop_front();
FileNameImageList::iterator itr;
for(itr = _filesRequested.begin();
itr != _filesRequested.end() && itr->second.valid();
++itr)
{
// osg::notify(osg::NOTICE)<<" merging previously loaded, but out of order file : "<<itr->first<<std::endl;
_images.push_back(itr->second);
}
_filesRequested.erase(_filesRequested.begin(), itr);
}
}
else
{
_images.push_back(image);
}
computeTimePerImage();
if (data()==0)
{
_imageIterator = _images.begin();
_imageIteratorTime = 0.0;
setImageToChild(_imageIterator->get());
}
}
void ImageSequence::setImageToChild(const osg::Image* image)
{
// osg::notify(osg::NOTICE)<<"setImageToChild("<<image<<")"<<std::endl;
if (image==0) return;
setImage(image->s(),image->t(),image->r(),
image->getInternalTextureFormat(),
image->getPixelFormat(),image->getDataType(),
const_cast<unsigned char*>(image->data()),
osg::Image::NO_DELETE,
image->getPacking());
}
void ImageSequence::update(osg::NodeVisitor* nv)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
osg::NodeVisitor::ImageRequestHandler* irh = nv->getImageRequestHandler();
const osg::FrameStamp* fs = nv->getFrameStamp();
// osg::notify(osg::NOTICE)<<"ImageSequence::update("<<fs<<", "<<irh<<")"<<std::endl;
if (_referenceTime == DBL_MAX)
{
_referenceTime = fs->getSimulationTime();
}
bool looping = getLoopingMode()==LOOPING;
double time = (fs->getSimulationTime() - _referenceTime)*_timeMultiplier;
if (_seekTimeSet || _status==PAUSED || _status==INVALID)
{
time = _seekTime;
_referenceTime = fs->getSimulationTime() - time/_timeMultiplier;
}
if (time>_length)
{
time -= floor(time/_length)*_length;
}
_seekTime = time;
_seekTimeSet = false;
FileNames::iterator previous_fileNamesIterator = _fileNamesIterator;
Images::iterator previous_imageIterator = _imageIterator;
bool pruneOldImages = false;
switch(_mode)
{
case(PRE_LOAD_ALL_IMAGES):
{
if (_fileNames.size()>_images.size())
{
FileNames::iterator itr = _fileNames.begin();
for(unsigned int i=0;i<_images.size();++i) ++itr;
for(; itr!=_fileNames.end(); ++itr)
{
osg::Image* image = irh->readImageFile(*itr);
_images.push_back(image);
}
}
irh = 0;
break;
}
case(PAGE_AND_RETAIN_IMAGES):
{
break;
}
case(PAGE_AND_DISCARD_USED_IMAGES):
{
pruneOldImages = true;
break;
}
}
// osg::notify(osg::NOTICE)<<"time = "<<time<<std::endl;
if (irh && _images.size()<_fileNames.size())
{
double preLoadTime = time + osg::minimum(irh->getPreLoadTime()*_timeMultiplier, _length);
if (preLoadTime>=_length)
{
//
// Advance fileNameIterator to end and wrap around
//
for(;
_fileNamesIterator != _fileNames.end();
++_fileNamesIterator)
{
_fileNamesIteratorTime += _timePerImage;
double effectTime = fs->getSimulationTime() + (preLoadTime - _fileNamesIteratorTime);
_filesRequested.push_back(FileNameImagePair(*_fileNamesIterator,0));
irh->requestImageFile(*_fileNamesIterator, this, effectTime, fs);
}
preLoadTime -= _length;
if (looping)
{
_fileNamesIterator = _fileNames.begin();
_fileNamesIteratorTime = 0.0;
}
}
if (_fileNamesIterator!=_fileNames.end())
{
//
// Advance fileNameIterator to encmpass preLoadTime
//
//osg::notify(osg::NOTICE)<<" _fileNamesIteratorTime = "<<_fileNamesIteratorTime<<" "<<_timePerImage<<std::endl;
while(preLoadTime > (_fileNamesIteratorTime + _timePerImage))
{
_fileNamesIteratorTime += _timePerImage;
//osg::notify(osg::NOTICE)<<" _fileNamesIteratorTime = "<<_fileNamesIteratorTime<<std::endl;
//osg::notify(osg::NOTICE)<<" need to preLoad = "<<*_fileNamesIterator<<std::endl;
++_fileNamesIterator;
if (previous_fileNamesIterator==_fileNamesIterator) break;
if (_fileNamesIterator ==_fileNames.end())
{
// return iterator to begining of set.
if (looping) _fileNamesIterator = _fileNames.begin();
else break;
}
double effectTime = fs->getSimulationTime() + (preLoadTime - _fileNamesIteratorTime);
_filesRequested.push_back(FileNameImagePair(*_fileNamesIterator,0));
irh->requestImageFile(*_fileNamesIterator, this, effectTime, fs);
}
}
if (looping && _fileNamesIterator==_fileNames.end())
{
_fileNamesIterator = _fileNames.begin();
_fileNamesIteratorTime = 0.0;
}
}
{
//
// Advance imageIterator
//
if (time<_imageIteratorTime)
{
_imageIterator = _images.begin();
_imageIteratorTime = 0.0;
}
if (_imageIterator!=_images.end())
{
// osg::notify(osg::NOTICE)<<" _imageIteratorTime = "<<_imageIteratorTime<<std::endl;
while(time > (_imageIteratorTime + _timePerImage))
{
_imageIteratorTime += _timePerImage;
// osg::notify(osg::NOTICE)<<" _imageIteratorTime = "<<_imageIteratorTime<<std::endl;
++_imageIterator;
if (_imageIterator ==_images.end())
{
if (pruneOldImages)
{
_images.erase(previous_imageIterator, _imageIterator);
previous_imageIterator = _images.begin();
}
if (looping)
{
// return iterator to begining of set.
_imageIterator = _images.begin();
}
else
{
break;
}
}
}
}
if (looping && _imageIterator==_images.end())
{
_imageIterator = _images.begin();
}
}
if (_imageIterator!=_images.end() && previous_imageIterator != _imageIterator)
{
if (pruneOldImages)
{
_images.erase(previous_imageIterator, _imageIterator);
}
setImageToChild(_imageIterator->get());
}
}
Fix for when looping is is disabled
git-svn-id: 23b6355f2bb369032457de4eb5f713ee134f73a8@8832 16af8721-9629-0410-8352-f15c8da7e697
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#include <OpenThreads/ScopedLock>
#include <osg/ImageSequence>
#include <osg/Notify>
#include <osg/Camera>
#include <osg/NodeVisitor>
#include <osg/Texture2D>
#include <math.h>
using namespace osg;
void ImageSequence::UpdateCallback::operator () (osg::StateAttribute* attr, osg::NodeVisitor* nv)
{
osg::Texture* texture = attr ? attr->asTexture() : 0;
// osg::notify(osg::NOTICE)<<"ImageSequence::UpdateCallback::"<<texture<<std::endl;
if (texture)
{
for(unsigned int i=0; i<texture->getNumImages(); ++i)
{
texture->getImage(i)->update(nv);
}
}
}
ImageSequence::ImageSequence()
{
_referenceTime = DBL_MAX;
_timeMultiplier = 1.0;
_mode = PRE_LOAD_ALL_IMAGES;
_length = 1.0;
_timePerImage = 1.0;
_fileNamesIterator = _fileNames.end();
_fileNamesIteratorTime = 0.0;
_imageIterator = _images.end();
_imageIteratorTime = 0.0;
_seekTime = 0.0;
_seekTimeSet = false;
}
ImageSequence::ImageSequence(const ImageSequence& is,const CopyOp& copyop):
osg::ImageStream(is,copyop),
_referenceTime(is._referenceTime),
_timeMultiplier(is._timeMultiplier),
_mode(is._mode),
_length(is._length),
_timePerImage(is._timePerImage)
{
_fileNamesIterator = _fileNames.end();
_fileNamesIteratorTime = 0.0;
_imageIterator = _images.end();
_imageIteratorTime = 0.0;
_seekTime = is._seekTime;
_seekTimeSet = is._seekTimeSet;
}
int ImageSequence::compare(const Image& rhs) const
{
return ImageStream::compare(rhs);
}
void ImageSequence::seek(double time)
{
_seekTime = time;
_seekTimeSet = true;
}
void ImageSequence::play()
{
_status=PLAYING;
}
void ImageSequence::pause()
{
_status=PAUSED;
}
void ImageSequence::rewind()
{
seek(0.0f);
}
void ImageSequence::setMode(Mode mode)
{
_mode = mode;
}
void ImageSequence::setLength(double length)
{
_length = length;
computeTimePerImage();
}
void ImageSequence::computeTimePerImage()
{
if (!_fileNames.empty()) _timePerImage = _length / double(_fileNames.size());
else if (!_images.empty()) _timePerImage = _length / double(_images.size());
else _timePerImage = _length;
}
void ImageSequence::addImageFile(const std::string& fileName)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
_fileNames.push_back(fileName);
computeTimePerImage();
if (_fileNamesIterator==_fileNames.end())
{
_fileNamesIterator = _fileNames.begin();
_fileNamesIteratorTime = _referenceTime;
}
}
void ImageSequence::addImage(osg::Image* image)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
if (!_filesRequested.empty())
{
// follows is a mechanism that ensures that requested images
// get merged in the correct time order.
if (_filesRequested.front().first != image->getFileName())
{
for(FileNameImageList::iterator itr = _filesRequested.begin();
itr != _filesRequested.end();
++itr)
{
if (itr->first == image->getFileName())
{
osg::notify(osg::NOTICE)<<"inserting image into waiting stake : "<<image->getFileName()<<std::endl;
itr->second = image;
return;
}
}
// osg::notify(osg::NOTICE)<<"image not expected : "<<image->getFileName()<<std::endl;
_images.push_back(image);
}
else
{
// osg::notify(osg::NOTICE)<<"merging image in order expected : "<<image->getFileName()<<std::endl;
_images.push_back(image);
_filesRequested.pop_front();
FileNameImageList::iterator itr;
for(itr = _filesRequested.begin();
itr != _filesRequested.end() && itr->second.valid();
++itr)
{
// osg::notify(osg::NOTICE)<<" merging previously loaded, but out of order file : "<<itr->first<<std::endl;
_images.push_back(itr->second);
}
_filesRequested.erase(_filesRequested.begin(), itr);
}
}
else
{
_images.push_back(image);
}
computeTimePerImage();
if (data()==0)
{
_imageIterator = _images.begin();
_imageIteratorTime = 0.0;
setImageToChild(_imageIterator->get());
}
}
void ImageSequence::setImageToChild(const osg::Image* image)
{
// osg::notify(osg::NOTICE)<<"setImageToChild("<<image<<")"<<std::endl;
if (image==0) return;
setImage(image->s(),image->t(),image->r(),
image->getInternalTextureFormat(),
image->getPixelFormat(),image->getDataType(),
const_cast<unsigned char*>(image->data()),
osg::Image::NO_DELETE,
image->getPacking());
}
void ImageSequence::update(osg::NodeVisitor* nv)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
osg::NodeVisitor::ImageRequestHandler* irh = nv->getImageRequestHandler();
const osg::FrameStamp* fs = nv->getFrameStamp();
// osg::notify(osg::NOTICE)<<"ImageSequence::update("<<fs<<", "<<irh<<")"<<std::endl;
if (_referenceTime == DBL_MAX)
{
_referenceTime = fs->getSimulationTime();
}
bool looping = getLoopingMode()==LOOPING;
double time = (fs->getSimulationTime() - _referenceTime)*_timeMultiplier;
if (_seekTimeSet || _status==PAUSED || _status==INVALID)
{
time = _seekTime;
_referenceTime = fs->getSimulationTime() - time/_timeMultiplier;
}
if (time>_length)
{
time -= floor(time/_length)*_length;
}
_seekTime = time;
// _seekTimeSet = false;
FileNames::iterator previous_fileNamesIterator = _fileNamesIterator;
Images::iterator previous_imageIterator = _imageIterator;
bool pruneOldImages = false;
switch(_mode)
{
case(PRE_LOAD_ALL_IMAGES):
{
if (_fileNames.size()>_images.size())
{
FileNames::iterator itr = _fileNames.begin();
for(unsigned int i=0;i<_images.size();++i) ++itr;
for(; itr!=_fileNames.end(); ++itr)
{
osg::Image* image = irh->readImageFile(*itr);
_images.push_back(image);
}
}
irh = 0;
break;
}
case(PAGE_AND_RETAIN_IMAGES):
{
break;
}
case(PAGE_AND_DISCARD_USED_IMAGES):
{
pruneOldImages = true;
break;
}
}
// osg::notify(osg::NOTICE)<<"time = "<<time<<std::endl;
if (irh && _images.size()<_fileNames.size())
{
double preLoadTime = time + osg::minimum(irh->getPreLoadTime()*_timeMultiplier, _length);
if (preLoadTime>=_length)
{
//
// Advance fileNameIterator to end and wrap around
//
for(;
_fileNamesIterator != _fileNames.end();
++_fileNamesIterator)
{
_fileNamesIteratorTime += _timePerImage;
double effectTime = fs->getSimulationTime() + (preLoadTime - _fileNamesIteratorTime);
_filesRequested.push_back(FileNameImagePair(*_fileNamesIterator,0));
irh->requestImageFile(*_fileNamesIterator, this, effectTime, fs);
}
preLoadTime -= _length;
if (looping)
{
_fileNamesIterator = _fileNames.begin();
_fileNamesIteratorTime = 0.0;
}
}
if (_fileNamesIterator!=_fileNames.end())
{
//
// Advance fileNameIterator to encmpass preLoadTime
//
//osg::notify(osg::NOTICE)<<" _fileNamesIteratorTime = "<<_fileNamesIteratorTime<<" "<<_timePerImage<<std::endl;
while(preLoadTime > (_fileNamesIteratorTime + _timePerImage))
{
_fileNamesIteratorTime += _timePerImage;
//osg::notify(osg::NOTICE)<<" _fileNamesIteratorTime = "<<_fileNamesIteratorTime<<std::endl;
//osg::notify(osg::NOTICE)<<" need to preLoad = "<<*_fileNamesIterator<<std::endl;
++_fileNamesIterator;
if (previous_fileNamesIterator==_fileNamesIterator) break;
if (_fileNamesIterator ==_fileNames.end())
{
// return iterator to begining of set.
if (looping) _fileNamesIterator = _fileNames.begin();
else break;
}
double effectTime = fs->getSimulationTime() + (preLoadTime - _fileNamesIteratorTime);
_filesRequested.push_back(FileNameImagePair(*_fileNamesIterator,0));
irh->requestImageFile(*_fileNamesIterator, this, effectTime, fs);
}
}
if (looping && _fileNamesIterator==_fileNames.end())
{
_fileNamesIterator = _fileNames.begin();
_fileNamesIteratorTime = 0.0;
}
}
{
//
// Advance imageIterator
//
if ((looping || _seekTimeSet) && time<_imageIteratorTime)
{
_imageIterator = _images.begin();
_imageIteratorTime = 0.0;
}
if (_imageIterator!=_images.end())
{
// osg::notify(osg::NOTICE)<<" _imageIteratorTime = "<<_imageIteratorTime<<std::endl;
while(time > (_imageIteratorTime + _timePerImage))
{
_imageIteratorTime += _timePerImage;
// osg::notify(osg::NOTICE)<<" _imageIteratorTime = "<<_imageIteratorTime<<std::endl;
++_imageIterator;
if (_imageIterator ==_images.end())
{
if (pruneOldImages)
{
_images.erase(previous_imageIterator, _imageIterator);
previous_imageIterator = _images.begin();
}
if (looping)
{
// return iterator to begining of set.
_imageIterator = _images.begin();
}
else
{
break;
}
}
}
}
if (looping && _imageIterator==_images.end())
{
_imageIterator = _images.begin();
}
}
if (_imageIterator!=_images.end() && previous_imageIterator != _imageIterator)
{
if (pruneOldImages)
{
_images.erase(previous_imageIterator, _imageIterator);
}
setImageToChild(_imageIterator->get());
}
_seekTimeSet = false;
}
|
/*------------------------------------------------------------------------
* (The MIT License)
*
* Copyright (c) 2008-2011 Rhomobile, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* http://rhomobile.com
*------------------------------------------------------------------------*/
#include "rhodes/jni/com_rhomobile_rhodes_RhodesService.h"
#include "rhodes/jni/com_rhomobile_rhodes_RhodesAppOptions.h"
#include <common/RhoConf.h>
#include <common/app_build_configs.h>
#include <logging/RhoLogConf.h>
#include <common/RhodesApp.h>
#include <common/AutoPointer.h>
#include <sync/RhoconnectClientManager.h>
#include "Push.h"
#include "rhodes/JNIRhodes.h"
#include "rhodes/JNIRhoRuby.h"
#include "rhodes/RhoClassFactory.h"
#undef DEFAULT_LOGCATEGORY
#define DEFAULT_LOGCATEGORY "RhodesAppJNI"
static rho::common::CAutoPtr<rho::common::AndroidNetworkStatusMonitor> s_network_status_monitor(new rho::common::AndroidNetworkStatusMonitor());
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_makeLink
(JNIEnv *env, jclass, jstring src, jstring dst)
{
// We should not use rho_cast functions here because this function
// called very early when jnienv() is not yet initialized
const char *strSrc = env->GetStringUTFChars(src, JNI_FALSE);
const char *strDst = env->GetStringUTFChars(dst, JNI_FALSE);
::unlink(strDst);
int err = ::symlink(strSrc, strDst);
env->ReleaseStringUTFChars(src, strSrc);
env->ReleaseStringUTFChars(dst, strDst);
if (err != 0)
env->ThrowNew(getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION), "Can not create symlink");
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_getInvalidSecurityTokenMessage(JNIEnv* env, jclass) {
const char* message = "Invalid security token !";
//rho_conf_Init(rho_native_rhopath());
if (rho_conf_is_property_exists("invalid_security_token_message")) {
const char* conf_message = rho_conf_getString("invalid_security_token_message");
message = conf_message;
}
jstring objStr = env->NewStringUTF(message);
return objStr;
}
static jobject g_classLoader = NULL;
static jmethodID g_loadClass = NULL;
jclass rho_find_class(JNIEnv *env, const char *c)
{
RAWTRACE2("%s - %s", __FUNCTION__, c);
jstring className = env->NewStringUTF(c);
jclass cls = (jclass)env->CallObjectMethod(g_classLoader, g_loadClass, className);
if(env->ExceptionCheck() == JNI_TRUE) {
env->ExceptionClear();
cls = 0;
} else
{
env->DeleteLocalRef(className);
}
return cls;
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_initClassLoader
(JNIEnv *env, jclass, jobject cl)
{
g_classLoader = env->NewGlobalRef(cl);
jclass javaLangClassLoader = env->FindClass("java/lang/ClassLoader");
g_loadClass = env->GetMethodID(javaLangClassLoader, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_setupRhodesApp
(JNIEnv *env, jclass)
{
android_setup(env);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_createRhodesApp
(JNIEnv *env, jclass)
{
// Start Rhodes application
rho_rhodesapp_create(rho_native_rhopath());
RHODESAPP().setNetworkStatusMonitor(s_network_status_monitor);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_startRhodesApp
(JNIEnv *, jclass)
{
rho_rhodesapp_start();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_stopRhodesApp
(JNIEnv *, jclass)
{
rho_rhodesapp_destroy();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doSyncAllSources
(JNIEnv *, jobject, jboolean show_status_popup)
{
//rho_sync_doSyncAllSources(show_status_popup, "", 0);
if ( rho::sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) {
rho::sync::RhoconnectClientManager::doSyncAllSources(show_status_popup,"",0);
}
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doSyncSource
(JNIEnv *env, jobject, jstring sourceObj)
{
if ( rho::sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) {
std::string source = rho_cast<std::string>(env, sourceObj);
// rho_sync_doSyncSourceByName(source.c_str());
rho::sync::RhoconnectClientManager::doSyncSourceByName(source.c_str());
}
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_setStartParameters
(JNIEnv *env, jclass, jstring strUrl)
{
std::string url = rho_cast<std::string>(env, strUrl);
RHODESAPP().setStartParameters(url.c_str());
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getOptionsUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getOptionsUrl().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getStartUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getStartUrl().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getCurrentUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getCurrentUrl(0).c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getAppBackUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getAppBackUrl().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getBlobPath
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getBlobsDirPath().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequest
(JNIEnv *env, jclass, jstring strUrl)
{
std::string url = rho_cast<std::string>(env, strUrl);
rho_net_request(url.c_str());
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequestAsync
(JNIEnv *env, jclass, jstring strUrl)
{
std::string url = rho_cast<std::string>(env, strUrl);
RHODESAPP().runCallbackInThread(url, "");
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequestEx
(JNIEnv *env, jclass, jstring jUrl, jstring jBody, jstring jData, jboolean waitForResponse)
{
std::string url = rho_cast<std::string>(env, jUrl);
std::string body = rho_cast<std::string>(env, jBody);
std::string data = rho_cast<std::string>(env, jData);
RHODESAPP().callCallbackWithData(url, body, data, waitForResponse);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequestJson
(JNIEnv *env, jclass, jstring jUrl, jstring jBody, jstring jData, jboolean waitForResponse)
{
std::string url = rho_cast<std::string>(env, jUrl);
std::string body = rho_cast<std::string>(env, jBody);
std::string data = rho_cast<std::string>(env, jData);
RHODESAPP().callCallbackWithJsonBody(url.c_str(), body.c_str(), data.c_str(), waitForResponse);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_normalizeUrl
(JNIEnv *env, jobject, jstring strUrl)
{
std::string const &s = rho_cast<std::string>(env, strUrl);
std::string const &cs = RHODESAPP().canonicalizeRhoUrl(s);
return rho_cast<jstring>(env, cs);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_getBuildConfig
(JNIEnv *env, jclass, jstring key)
{
std::string const &s = rho_cast<std::string>(env, key);
const char* cs = get_app_build_config_item(s.c_str());
return rho_cast<jstring>(env, cs);
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isMotorolaLicencePassed
(JNIEnv *env, jclass, jstring jLicense, jstring jCompany, jstring jAppName)
{
int res = rho_can_app_started_with_current_licence(
jLicense ? rho_cast<std::string>(env, jLicense).c_str() : 0,
jCompany ? rho_cast<std::string>(env, jCompany).c_str() : 0,
jAppName ? rho_cast<std::string>(env, jAppName).c_str() : 0);
return (jboolean)(res == 1);
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isTitleEnabled
(JNIEnv *, jclass)
{
bool value = true;
const char* svalue = get_app_build_config_item("android_title");
if (svalue != NULL) {
value = svalue[0] != '0';
}
return (jboolean)value;
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesApplication_canStartApp
(JNIEnv *env, jclass, jstring cmdLine, jstring sep)
{
std::string const &strCmdLine = rho_cast<std::string>(env, cmdLine);
std::string const &strSep = rho_cast<std::string>(env, sep);
int nRes = rho_rhodesapp_canstartapp(strCmdLine.c_str(), strSep.c_str());
return (jboolean)(nRes ? true : false);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_navigateBack
(JNIEnv *, jclass)
{
rho_rhodesapp_navigate_back();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_loadUrl
(JNIEnv *env, jclass, jstring str)
{
rho_rhodesapp_load_url(rho_cast<std::string>(env, str).c_str());
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_onScreenOrientationChanged
(JNIEnv *env, jclass, jint width, jint height, jint angle)
{
rho_rhodesapp_callScreenRotationCallback(width, height, angle);
//RAWLOG_ERROR3("$$$$$$$$$$$$$$$$ SCREEN : [%d]x[%d] angle[%d]", width, height, angle);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_callUiCreatedCallback
(JNIEnv *, jclass)
{
rho_rhodesapp_callUiCreatedCallback();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_callUiDestroyedCallback
(JNIEnv *, jclass)
{
rho_rhodesapp_callUiDestroyedCallback();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_callActivationCallback
(JNIEnv *, jclass, jboolean active)
{
rho_rhodesapp_callAppActiveCallback(active);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_setPushRegistrationId
(JNIEnv *env, jobject, jstring jType, jstring jId)
{
std::string strType = jType ? rho_cast<std::string>(env, jType) : "";
std::string deviceId = rho_cast<std::string>(env, jId);
rho::push::CPushManager::getInstance()->setDeviceId(strType, deviceId);
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_callPushCallback
(JNIEnv *env, jobject, jstring jType, jstring jJson)
{
std::string strType = jType ? rho_cast<std::string>(env, jType) : "";
std::string strJson = jJson ? rho_cast<std::string>(env, jJson) : "";
rho::push::CPushManager::getInstance()->callBack(strType, strJson);
return (jboolean)true;
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_resetHttpLogging
(JNIEnv *env, jobject, jstring jId)
{
//RAWLOG_ERROR("$$$$$$$$$$$ RESET HTTP LOGGING 1 $$$$$$$$$$$$$");
std::string url = rho_cast<std::string>(env, jId);
rho_log_resetup_http_url(url.c_str());
//RAWLOG_ERROR("$$$$$$$$$$$ RESET HTTP LOGGING 2 $$$$$$$$$$$$$");
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_resetFileLogging
(JNIEnv *env, jobject, jstring jId)
{
std::string path = rho_cast<std::string>(env, jId);
LOGCONF().setLogFilePath(path);
}
RHO_GLOBAL char *rho_timezone()
{
static char *tz = NULL;
if (!tz)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return NULL;
jmethodID mid = getJNIClassStaticMethod(env, cls, "getTimezoneStr", "()Ljava/lang/String;");
if (!mid) return NULL;
jstring s = (jstring)env->CallStaticObjectMethod(cls, mid);
std::string tzs = rho_cast<std::string>(env, s);
tz = strdup(tzs.c_str());
}
return tz;
}
RHO_GLOBAL void rho_conf_show_log()
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "showLogView", "()V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_notifyNetworkStatusChanged(JNIEnv *env, jobject, int status)
{
RAWLOG_ERROR("nativeNotify");
rho::common::enNetworkStatus s = rho::common::networkStatusUnknown;
switch(status)
{
case 1:
s = rho::common::networkStatusConnected;
break;
case 2:
s = rho::common::networkStatusDisconnected;
break;
}
s_network_status_monitor->notifyReceiver(s);
}
platform/android/Rhodes/jni/src/rhodesapp.cpp: Android stub for rho_title_change
/*------------------------------------------------------------------------
* (The MIT License)
*
* Copyright (c) 2008-2011 Rhomobile, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* http://rhomobile.com
*------------------------------------------------------------------------*/
#include "rhodes/jni/com_rhomobile_rhodes_RhodesService.h"
#include "rhodes/jni/com_rhomobile_rhodes_RhodesAppOptions.h"
#include <common/RhoConf.h>
#include <common/app_build_configs.h>
#include <logging/RhoLogConf.h>
#include <common/RhodesApp.h>
#include <common/AutoPointer.h>
#include <sync/RhoconnectClientManager.h>
#include "Push.h"
#include "rhodes/JNIRhodes.h"
#include "rhodes/JNIRhoRuby.h"
#include "rhodes/RhoClassFactory.h"
#undef DEFAULT_LOGCATEGORY
#define DEFAULT_LOGCATEGORY "RhodesAppJNI"
static rho::common::CAutoPtr<rho::common::AndroidNetworkStatusMonitor> s_network_status_monitor(new rho::common::AndroidNetworkStatusMonitor());
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_makeLink
(JNIEnv *env, jclass, jstring src, jstring dst)
{
// We should not use rho_cast functions here because this function
// called very early when jnienv() is not yet initialized
const char *strSrc = env->GetStringUTFChars(src, JNI_FALSE);
const char *strDst = env->GetStringUTFChars(dst, JNI_FALSE);
::unlink(strDst);
int err = ::symlink(strSrc, strDst);
env->ReleaseStringUTFChars(src, strSrc);
env->ReleaseStringUTFChars(dst, strDst);
if (err != 0)
env->ThrowNew(getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION), "Can not create symlink");
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_getInvalidSecurityTokenMessage(JNIEnv* env, jclass) {
const char* message = "Invalid security token !";
//rho_conf_Init(rho_native_rhopath());
if (rho_conf_is_property_exists("invalid_security_token_message")) {
const char* conf_message = rho_conf_getString("invalid_security_token_message");
message = conf_message;
}
jstring objStr = env->NewStringUTF(message);
return objStr;
}
static jobject g_classLoader = NULL;
static jmethodID g_loadClass = NULL;
jclass rho_find_class(JNIEnv *env, const char *c)
{
RAWTRACE2("%s - %s", __FUNCTION__, c);
jstring className = env->NewStringUTF(c);
jclass cls = (jclass)env->CallObjectMethod(g_classLoader, g_loadClass, className);
if(env->ExceptionCheck() == JNI_TRUE) {
env->ExceptionClear();
cls = 0;
} else
{
env->DeleteLocalRef(className);
}
return cls;
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_initClassLoader
(JNIEnv *env, jclass, jobject cl)
{
g_classLoader = env->NewGlobalRef(cl);
jclass javaLangClassLoader = env->FindClass("java/lang/ClassLoader");
g_loadClass = env->GetMethodID(javaLangClassLoader, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_setupRhodesApp
(JNIEnv *env, jclass)
{
android_setup(env);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_createRhodesApp
(JNIEnv *env, jclass)
{
// Start Rhodes application
rho_rhodesapp_create(rho_native_rhopath());
RHODESAPP().setNetworkStatusMonitor(s_network_status_monitor);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_startRhodesApp
(JNIEnv *, jclass)
{
rho_rhodesapp_start();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_stopRhodesApp
(JNIEnv *, jclass)
{
rho_rhodesapp_destroy();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doSyncAllSources
(JNIEnv *, jobject, jboolean show_status_popup)
{
//rho_sync_doSyncAllSources(show_status_popup, "", 0);
if ( rho::sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) {
rho::sync::RhoconnectClientManager::doSyncAllSources(show_status_popup,"",0);
}
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doSyncSource
(JNIEnv *env, jobject, jstring sourceObj)
{
if ( rho::sync::RhoconnectClientManager::haveRhoconnectClientImpl() ) {
std::string source = rho_cast<std::string>(env, sourceObj);
// rho_sync_doSyncSourceByName(source.c_str());
rho::sync::RhoconnectClientManager::doSyncSourceByName(source.c_str());
}
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesApplication_setStartParameters
(JNIEnv *env, jclass, jstring strUrl)
{
std::string url = rho_cast<std::string>(env, strUrl);
RHODESAPP().setStartParameters(url.c_str());
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getOptionsUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getOptionsUrl().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getStartUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getStartUrl().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getCurrentUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getCurrentUrl(0).c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getAppBackUrl
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getAppBackUrl().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesAppOptions_getBlobPath
(JNIEnv *env, jclass)
{
const char *s = RHODESAPP().getBlobsDirPath().c_str();
return rho_cast<jstring>(env, s);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequest
(JNIEnv *env, jclass, jstring strUrl)
{
std::string url = rho_cast<std::string>(env, strUrl);
rho_net_request(url.c_str());
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequestAsync
(JNIEnv *env, jclass, jstring strUrl)
{
std::string url = rho_cast<std::string>(env, strUrl);
RHODESAPP().runCallbackInThread(url, "");
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequestEx
(JNIEnv *env, jclass, jstring jUrl, jstring jBody, jstring jData, jboolean waitForResponse)
{
std::string url = rho_cast<std::string>(env, jUrl);
std::string body = rho_cast<std::string>(env, jBody);
std::string data = rho_cast<std::string>(env, jData);
RHODESAPP().callCallbackWithData(url, body, data, waitForResponse);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_doRequestJson
(JNIEnv *env, jclass, jstring jUrl, jstring jBody, jstring jData, jboolean waitForResponse)
{
std::string url = rho_cast<std::string>(env, jUrl);
std::string body = rho_cast<std::string>(env, jBody);
std::string data = rho_cast<std::string>(env, jData);
RHODESAPP().callCallbackWithJsonBody(url.c_str(), body.c_str(), data.c_str(), waitForResponse);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_normalizeUrl
(JNIEnv *env, jobject, jstring strUrl)
{
std::string const &s = rho_cast<std::string>(env, strUrl);
std::string const &cs = RHODESAPP().canonicalizeRhoUrl(s);
return rho_cast<jstring>(env, cs);
}
RHO_GLOBAL jstring JNICALL Java_com_rhomobile_rhodes_RhodesService_getBuildConfig
(JNIEnv *env, jclass, jstring key)
{
std::string const &s = rho_cast<std::string>(env, key);
const char* cs = get_app_build_config_item(s.c_str());
return rho_cast<jstring>(env, cs);
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isMotorolaLicencePassed
(JNIEnv *env, jclass, jstring jLicense, jstring jCompany, jstring jAppName)
{
int res = rho_can_app_started_with_current_licence(
jLicense ? rho_cast<std::string>(env, jLicense).c_str() : 0,
jCompany ? rho_cast<std::string>(env, jCompany).c_str() : 0,
jAppName ? rho_cast<std::string>(env, jAppName).c_str() : 0);
return (jboolean)(res == 1);
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_isTitleEnabled
(JNIEnv *, jclass)
{
bool value = true;
const char* svalue = get_app_build_config_item("android_title");
if (svalue != NULL) {
value = svalue[0] != '0';
}
return (jboolean)value;
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesApplication_canStartApp
(JNIEnv *env, jclass, jstring cmdLine, jstring sep)
{
std::string const &strCmdLine = rho_cast<std::string>(env, cmdLine);
std::string const &strSep = rho_cast<std::string>(env, sep);
int nRes = rho_rhodesapp_canstartapp(strCmdLine.c_str(), strSep.c_str());
return (jboolean)(nRes ? true : false);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_navigateBack
(JNIEnv *, jclass)
{
rho_rhodesapp_navigate_back();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_loadUrl
(JNIEnv *env, jclass, jstring str)
{
rho_rhodesapp_load_url(rho_cast<std::string>(env, str).c_str());
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_onScreenOrientationChanged
(JNIEnv *env, jclass, jint width, jint height, jint angle)
{
rho_rhodesapp_callScreenRotationCallback(width, height, angle);
//RAWLOG_ERROR3("$$$$$$$$$$$$$$$$ SCREEN : [%d]x[%d] angle[%d]", width, height, angle);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_callUiCreatedCallback
(JNIEnv *, jclass)
{
rho_rhodesapp_callUiCreatedCallback();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_callUiDestroyedCallback
(JNIEnv *, jclass)
{
rho_rhodesapp_callUiDestroyedCallback();
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_callActivationCallback
(JNIEnv *, jclass, jboolean active)
{
rho_rhodesapp_callAppActiveCallback(active);
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_setPushRegistrationId
(JNIEnv *env, jobject, jstring jType, jstring jId)
{
std::string strType = jType ? rho_cast<std::string>(env, jType) : "";
std::string deviceId = rho_cast<std::string>(env, jId);
rho::push::CPushManager::getInstance()->setDeviceId(strType, deviceId);
}
RHO_GLOBAL jboolean JNICALL Java_com_rhomobile_rhodes_RhodesService_callPushCallback
(JNIEnv *env, jobject, jstring jType, jstring jJson)
{
std::string strType = jType ? rho_cast<std::string>(env, jType) : "";
std::string strJson = jJson ? rho_cast<std::string>(env, jJson) : "";
rho::push::CPushManager::getInstance()->callBack(strType, strJson);
return (jboolean)true;
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_resetHttpLogging
(JNIEnv *env, jobject, jstring jId)
{
//RAWLOG_ERROR("$$$$$$$$$$$ RESET HTTP LOGGING 1 $$$$$$$$$$$$$");
std::string url = rho_cast<std::string>(env, jId);
rho_log_resetup_http_url(url.c_str());
//RAWLOG_ERROR("$$$$$$$$$$$ RESET HTTP LOGGING 2 $$$$$$$$$$$$$");
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_resetFileLogging
(JNIEnv *env, jobject, jstring jId)
{
std::string path = rho_cast<std::string>(env, jId);
LOGCONF().setLogFilePath(path);
}
RHO_GLOBAL char *rho_timezone()
{
static char *tz = NULL;
if (!tz)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return NULL;
jmethodID mid = getJNIClassStaticMethod(env, cls, "getTimezoneStr", "()Ljava/lang/String;");
if (!mid) return NULL;
jstring s = (jstring)env->CallStaticObjectMethod(cls, mid);
std::string tzs = rho_cast<std::string>(env, s);
tz = strdup(tzs.c_str());
}
return tz;
}
RHO_GLOBAL void rho_conf_show_log()
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "showLogView", "()V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid);
}
RHO_GLOBAL void rho_title_change(const int tabIndex, const char* strTitle)
{
// not implemented
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_RhodesService_notifyNetworkStatusChanged(JNIEnv *env, jobject, int status)
{
RAWLOG_ERROR("nativeNotify");
rho::common::enNetworkStatus s = rho::common::networkStatusUnknown;
switch(status)
{
case 1:
s = rho::common::networkStatusConnected;
break;
case 2:
s = rho::common::networkStatusDisconnected;
break;
}
s_network_status_monitor->notifyReceiver(s);
}
|
#include "cinder/Camera.h"
#include "cinder/GeomIo.h"
#include "cinder/ImageIo.h"
#include "cinder/MayaCamUI.h"
#include "cinder/app/AppNative.h"
#include "cinder/app/RendererGl.h"
#include "cinder/gl/gl.h"
#include "cinder/gl/Batch.h"
#include "cinder/gl/Context.h"
#include "cinder/gl/GlslProg.h"
#include "cinder/gl/Texture.h"
#include "cinder/gl/VboMesh.h"
#include "cinder/params/Params.h"
#include "cinder/Log.h"
#include "DebugMesh.h"
using namespace ci;
using namespace ci::app;
using namespace std;
class GeometryApp : public AppNative {
public:
enum Primitive { CAPSULE, CONE, CUBE, CYLINDER, HELIX, ICOSAHEDRON, ICOSPHERE, SPHERE, TEAPOT, TORUS, PLANE };
enum Quality { LOW, DEFAULT, HIGH };
enum ViewMode { SHADED, WIREFRAME };
void prepareSettings( Settings *settings ) override;
void setup() override;
void resize() override;
void update() override;
void draw() override;
void mouseDown( MouseEvent event ) override;
void mouseDrag( MouseEvent event ) override;
void keyDown( KeyEvent event ) override;
private:
void createGrid();
void createPhongShader();
void createWireframeShader();
void createPrimitive();
void createParams();
void setSubdivision(int subdivision) { mSubdivision = math<int>::clamp(subdivision, 1, 5); createPrimitive(); }
int getSubdivision() const { return mSubdivision; }
void enableColors(bool enabled=true) { mShowColors = enabled; createPrimitive(); }
bool isColorsEnabled() const { return mShowColors; }
Primitive mPrimitiveSelected;
Primitive mPrimitiveCurrent;
Quality mQualitySelected;
Quality mQualityCurrent;
ViewMode mViewMode;
int mSubdivision;
bool mShowColors;
bool mShowNormals;
bool mShowGrid;
bool mEnableFaceFulling;
CameraPersp mCamera;
MayaCamUI mMayaCam;
bool mRecenterCamera;
vec3 mCameraCOI;
double mLastMouseDownTime;
gl::VertBatchRef mGrid;
gl::BatchRef mPrimitive;
gl::BatchRef mPrimitiveWireframe;
gl::BatchRef mPrimitiveNormalLines;
gl::GlslProgRef mPhongShader;
gl::GlslProgRef mWireframeShader;
gl::TextureRef mTexture;
#if ! defined( CINDER_GL_ES )
params::InterfaceGlRef mParams;
#endif
};
void GeometryApp::prepareSettings( Settings* settings )
{
settings->setWindowSize(1024, 768);
settings->enableHighDensityDisplay();
settings->enableMultiTouch( false );
}
void GeometryApp::setup()
{
// Initialize variables.
mPrimitiveSelected = mPrimitiveCurrent = TORUS;
mQualitySelected = mQualityCurrent = HIGH;
mViewMode = SHADED;
mLastMouseDownTime = 0;
mShowColors = false;
mShowNormals = false;
mShowGrid = true;
mEnableFaceFulling = false;
mSubdivision = 1;
// Load the textures.
gl::Texture::Format fmt;
fmt.setAutoInternalFormat();
fmt.setWrap( GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE );
mTexture = gl::Texture::create( loadImage( loadAsset("stripes.jpg") ), fmt );
// Setup the camera.
mCamera.setEyePoint( normalize( vec3( 3, 3, 6 ) ) * 5.0f );
mCamera.setCenterOfInterestPoint( mCameraCOI );
// Load and compile the shaders.
createPhongShader();
createWireframeShader();
// Create the meshes.
createGrid();
createPrimitive();
// Enable the depth buffer.
gl::enableDepthRead();
gl::enableDepthWrite();
// Create a parameter window, so we can toggle stuff.
createParams();
}
void GeometryApp::update()
{
// If another primitive or quality was selected, reset the subdivision and recreate the primitive.
if( mPrimitiveCurrent != mPrimitiveSelected || mQualitySelected != mQualityCurrent ) {
mSubdivision = 1;
mPrimitiveCurrent = mPrimitiveSelected;
mQualityCurrent = mQualitySelected;
createPrimitive();
}
// After creating a new primitive, gradually move the camera to get a good view.
if( mRecenterCamera ) {
float distance = glm::distance( mCamera.getEyePoint(), mCameraCOI );
mCamera.setEyePoint( mCameraCOI - lerp( distance, 5.0f, 0.1f ) * mCamera.getViewDirection() );
mCamera.setCenterOfInterestPoint( lerp( mCamera.getCenterOfInterestPoint(), mCameraCOI, 0.25f) );
}
}
void GeometryApp::draw()
{
// Prepare for drawing.
gl::clear( Color::black() );
gl::setMatrices( mCamera );
// Draw the grid.
if( mShowGrid && mGrid ) {
gl::ScopedGlslProg scopedGlslProg( gl::context()->getStockShader( gl::ShaderDef().color() ) );
mGrid->draw();
}
if( mPrimitive ) {
gl::ScopedTextureBind scopedTextureBind( mTexture );
// Rotate it slowly around the y-axis.
gl::pushModelView();
gl::rotate( float( getElapsedSeconds() / 5 ), 0.0f, 1.0f, 0.0f );
// Draw the normals.
if( mShowNormals && mPrimitiveNormalLines ) {
gl::ScopedColor colorScope( Color( 1, 1, 0 ) );
mPrimitiveNormalLines->draw();
}
// Draw the primitive.
gl::ScopedColor colorScope( Color( 0.7f, 0.5f, 0.3f ) );
// (If transparent, render the back side first).
if( mViewMode == WIREFRAME ) {
gl::enableAlphaBlending();
gl::enable( GL_CULL_FACE );
gl::cullFace( GL_FRONT );
mWireframeShader->uniform( "uBrightness", 0.5f );
mPrimitiveWireframe->draw();
}
// (Now render the front side.)
if( mViewMode == WIREFRAME ) {
gl::cullFace( GL_BACK );
mWireframeShader->uniform( "uBrightness", 1.0f );
mPrimitiveWireframe->draw();
gl::disable( GL_CULL_FACE );
gl::disableAlphaBlending();
}
else
mPrimitive->draw();
// Done.
gl::popModelView();
}
// Render the parameter window.
#if ! defined( CINDER_GL_ES )
if( mParams )
mParams->draw();
#endif
}
void GeometryApp::mouseDown( MouseEvent event )
{
mRecenterCamera = false;
mMayaCam.setCurrentCam( mCamera );
mMayaCam.mouseDown( event.getPos() );
if( getElapsedSeconds() - mLastMouseDownTime < 0.2f ) {
mPrimitiveSelected = static_cast<Primitive>( static_cast<int>(mPrimitiveSelected) + 1 );
createPrimitive();
}
mLastMouseDownTime = getElapsedSeconds();
}
void GeometryApp::mouseDrag( MouseEvent event )
{
mMayaCam.mouseDrag( event.getPos(), event.isLeftDown(), event.isMiddleDown(), event.isRightDown() );
mCamera = mMayaCam.getCamera();
}
void GeometryApp::resize()
{
mCamera.setAspectRatio( getWindowAspectRatio() );
if(mWireframeShader)
mWireframeShader->uniform( "uViewportSize", vec2( getWindowSize() ) );
}
void GeometryApp::keyDown( KeyEvent event )
{
switch( event.getCode() ) {
case KeyEvent::KEY_SPACE:
mPrimitiveSelected = static_cast<Primitive>( static_cast<int>(mPrimitiveSelected) + 1 );
createPrimitive();
break;
case KeyEvent::KEY_c:
mShowColors = ! mShowColors;
createPrimitive();
break;
case KeyEvent::KEY_n:
mShowNormals = ! mShowNormals;
break;
case KeyEvent::KEY_g:
mShowGrid = ! mShowGrid;
break;
case KeyEvent::KEY_q:
mQualitySelected = Quality( (int)( mQualitySelected + 1 ) % 3 );
break;
case KeyEvent::KEY_w:
if(mViewMode == WIREFRAME)
mViewMode = SHADED;
else
mViewMode = WIREFRAME;
break;
case KeyEvent::KEY_RETURN:
CI_LOG_V( "reload" );
createPhongShader();
createPrimitive();
break;
}
}
void GeometryApp::createParams()
{
#if ! defined( CINDER_GL_ES )
std::string primitives[] = { "Capsule", "Cone", "Cube", "Cylinder", "Helix", "Icosahedron", "Icosphere", "Sphere", "Teapot", "Torus", "Plane" };
std::string qualities[] = { "Low", "Default", "High" };
std::string viewmodes[] = { "Shaded", "Wireframe" };
mParams = params::InterfaceGl::create( getWindow(), "Geometry Demo", toPixels( ivec2( 300, 200 ) ) );
mParams->setOptions( "", "valueswidth=160 refresh=0.1" );
mParams->addParam( "Primitive", vector<string>(primitives,primitives+11), (int*) &mPrimitiveSelected );
mParams->addParam( "Quality", vector<string>(qualities,qualities+3), (int*) &mQualitySelected );
mParams->addParam( "Viewing Mode", vector<string>(viewmodes,viewmodes+2), (int*) &mViewMode );
mParams->addSeparator();
{
std::function<void(int)> setter = std::bind( &GeometryApp::setSubdivision, this, std::placeholders::_1 );
std::function<int()> getter = std::bind( &GeometryApp::getSubdivision, this );
mParams->addParam( "Subdivision", setter, getter );
}
mParams->addSeparator();
mParams->addParam( "Show Grid", &mShowGrid );
mParams->addParam( "Show Normals", &mShowNormals );
{
std::function<void(bool)> setter = std::bind( &GeometryApp::enableColors, this, std::placeholders::_1 );
std::function<bool()> getter = std::bind( &GeometryApp::isColorsEnabled, this );
mParams->addParam( "Show Colors", setter, getter );
}
mParams->addParam( "Face Culling", &mEnableFaceFulling ).updateFn( [&] { gl::enableFaceCulling( mEnableFaceFulling ); } );
#endif
}
void GeometryApp::createGrid()
{
mGrid = gl::VertBatch::create( GL_LINES );
mGrid->begin( GL_LINES );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( -10.0f, 0.0f, 0.0f );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(1, 0, 0) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(1, 0, 0) ); mGrid->vertex( 20.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 1, 0) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 1, 0) ); mGrid->vertex( 0.0f, 20.0f, 0.0f );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( 0.0f, 0.0f, -10.0f );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 0, 1) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 0, 1) ); mGrid->vertex( 0.0f, 0.0f, 20.0f );
for( int i = -10; i <= 10; ++i ) {
if( i == 0 )
continue;
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->vertex( float(i), 0.0f, -10.0f );
mGrid->vertex( float(i), 0.0f, +10.0f );
mGrid->vertex( -10.0f, 0.0f, float(i) );
mGrid->vertex( +10.0f, 0.0f, float(i) );
}
mGrid->end();
}
void GeometryApp::createPrimitive()
{
geom::SourceRef primitive;
std::string name;
switch( mPrimitiveCurrent ) {
default:
mPrimitiveSelected = CAPSULE;
case CAPSULE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Capsule( geom::Capsule() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Capsule( geom::Capsule().subdivisionsAxis( 6 ).subdivisionsHeight( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Capsule( geom::Capsule().subdivisionsAxis( 60 ).subdivisionsHeight( 20 ) ) ); break;
}
break;
case CONE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Cone() ); break;
case LOW: primitive = geom::SourceRef( new geom::Cone( geom::Cone().subdivisionsAxis( 6 ).subdivisionsHeight( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Cone( geom::Cone().subdivisionsAxis( 60 ).subdivisionsHeight( 60 ) ) ); break;
}
break;
case CUBE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Cube( geom::Cube() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Cube( geom::Cube().subdivisions( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Cube( geom::Cube().subdivisions( 10 ) ) ); break;
}
break;
case CYLINDER:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Cylinder( geom::Cylinder() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Cylinder( geom::Cylinder().subdivisionsAxis( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Cylinder( geom::Cylinder().subdivisionsAxis( 60 ).subdivisionsHeight( 20 ) ) ); break;
}
break;
case HELIX:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Helix( geom::Helix() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Helix( geom::Helix().subdivisionsHeight( 12 ).subdivisionsHeight( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Helix( geom::Helix().subdivisionsHeight( 60 ).subdivisionsHeight( 60 ) ) ); break;
}
break;
case ICOSAHEDRON:
primitive = geom::SourceRef( new geom::Icosahedron( geom::Icosahedron() ) );
break;
case ICOSPHERE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Icosphere( geom::Icosphere() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Icosphere( geom::Icosphere().subdivisions( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Icosphere( geom::Icosphere().subdivisions( 5 ) ) ); break;
}
break;
case SPHERE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Sphere( geom::Sphere() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Sphere( geom::Sphere().subdivisions( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Sphere( geom::Sphere().subdivisions( 60 ) ) ); break;
}
break;
case TEAPOT:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Teapot( geom::Teapot() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Teapot( geom::Teapot().subdivisions( 2 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Teapot( geom::Teapot().subdivisions( 12 ) ) ); break;
}
break;
case TORUS:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Torus( geom::Torus() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Torus( geom::Torus().subdivisionsAxis( 12 ).subdivisionsHeight( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Torus( geom::Torus().subdivisionsAxis( 60 ).subdivisionsHeight( 60 ) ) ); break;
}
break;
case PLANE:
ivec2 numSegments;
switch( mQualityCurrent ) {
case DEFAULT: numSegments = ivec2( 10, 10 ); break;
case LOW: numSegments = ivec2( 2, 2 ); break;
case HIGH: numSegments = ivec2( 100, 100 ); break;
}
auto plane = geom::Plane().subdivisions( numSegments );
// plane.normal( vec3( 0, 0, 1 ) ); // change the normal angle of the plane
// plane.axes( vec3( 0.70710678118, -0.70710678118, 0 ), vec3( 0.70710678118, 0.70710678118, 0 ) ); // dictate plane u/v axes directly
// plane.subdivisions( ivec2( 3, 10 ) ).size( vec2( 0.5f, 2.0f ) ).origin( vec3( 0, 1.0f, 0 ) ).normal( vec3( 0, 0, 1 ) ); // change the size and origin so that it is tall and thin, above the y axis.
primitive = geom::SourceRef( new geom::Plane( plane ) );
break;
}
// The purpose of the TriMesh is to capture a bounding box; without that need we could just instantiate the Batch directly using primitive
TriMesh::Format fmt = TriMesh::Format().positions().normals().texCoords();
if( mShowColors && primitive->getAvailableAttribs().count( geom::COLOR ) > 0 )
fmt.colors();
TriMesh mesh( *primitive, fmt );
AxisAlignedBox3f bbox = mesh.calcBoundingBox();
mCameraCOI = mesh.calcBoundingBox().getCenter();
mRecenterCamera = true;
if( mSubdivision > 1 )
mesh.subdivide( mSubdivision );
if( mPhongShader )
mPrimitive = gl::Batch::create( mesh, mPhongShader );
if( mWireframeShader )
mPrimitiveWireframe = gl::Batch::create( mesh, mWireframeShader );
vec3 size = bbox.getMax() - bbox.getMin();
float scale = std::max( std::max( size.x, size.y ), size.z ) / 25.0f;
mPrimitiveNormalLines = gl::Batch::create( geom::VertexNormalLines( mesh, scale ), gl::getStockShader( gl::ShaderDef().color() ) );
getWindow()->setTitle( "Geometry - " + to_string( mesh.getNumVertices() ) + " vertices" );
}
void GeometryApp::createPhongShader()
{
try {
#if defined( CINDER_GL_ES )
mPhongShader = gl::GlslProg::create( loadAsset( "phong_es2.vert" ), loadAsset( "phong_es2.frag" ) );
#else
mPhongShader = gl::GlslProg::create( loadAsset( "phong.vert" ), loadAsset( "phong.frag" ) );
#endif
}
catch( Exception &exc ) {
CI_LOG_E( "error loading phong shader: " << exc.what() );
}
}
void GeometryApp::createWireframeShader()
{
#if ! defined( CINDER_GL_ES )
try {
auto format = gl::GlslProg::Format()
.vertex( loadAsset( "wireframe.vert" ) )
.geometry( loadAsset( "wireframe.geom" ) )
.fragment( loadAsset( "wireframe.frag" ) );
mWireframeShader = gl::GlslProg::create( format );
}
catch( Exception &exc ) {
CI_LOG_E( "error loading wireframe shader: " << exc.what() );
}
#endif // ! defined( CINDER_GL_ES )
}
CINDER_APP_NATIVE( GeometryApp, RendererGl )
Simplified params with callbacks, whitespace fixes.
#include "cinder/Camera.h"
#include "cinder/GeomIo.h"
#include "cinder/ImageIo.h"
#include "cinder/MayaCamUI.h"
#include "cinder/app/AppNative.h"
#include "cinder/app/RendererGl.h"
#include "cinder/gl/gl.h"
#include "cinder/gl/Batch.h"
#include "cinder/gl/Context.h"
#include "cinder/gl/GlslProg.h"
#include "cinder/gl/Texture.h"
#include "cinder/gl/VboMesh.h"
#include "cinder/params/Params.h"
#include "cinder/Log.h"
#include "DebugMesh.h"
using namespace ci;
using namespace ci::app;
using namespace std;
class GeometryApp : public AppNative {
public:
enum Primitive { CAPSULE, CONE, CUBE, CYLINDER, HELIX, ICOSAHEDRON, ICOSPHERE, SPHERE, TEAPOT, TORUS, PLANE };
enum Quality { LOW, DEFAULT, HIGH };
enum ViewMode { SHADED, WIREFRAME };
void prepareSettings( Settings *settings ) override;
void setup() override;
void resize() override;
void update() override;
void draw() override;
void mouseDown( MouseEvent event ) override;
void mouseDrag( MouseEvent event ) override;
void keyDown( KeyEvent event ) override;
private:
void createGrid();
void createPhongShader();
void createWireframeShader();
void createPrimitive();
void createParams();
Primitive mPrimitiveSelected;
Primitive mPrimitiveCurrent;
Quality mQualitySelected;
Quality mQualityCurrent;
ViewMode mViewMode;
int mSubdivision;
bool mShowColors;
bool mShowNormals;
bool mShowGrid;
bool mEnableFaceFulling;
CameraPersp mCamera;
MayaCamUI mMayaCam;
bool mRecenterCamera;
vec3 mCameraCOI;
double mLastMouseDownTime;
gl::VertBatchRef mGrid;
gl::BatchRef mPrimitive;
gl::BatchRef mPrimitiveWireframe;
gl::BatchRef mPrimitiveNormalLines;
gl::GlslProgRef mPhongShader;
gl::GlslProgRef mWireframeShader;
gl::TextureRef mTexture;
#if ! defined( CINDER_GL_ES )
params::InterfaceGlRef mParams;
#endif
};
void GeometryApp::prepareSettings( Settings* settings )
{
settings->setWindowSize(1024, 768);
settings->enableHighDensityDisplay();
settings->enableMultiTouch( false );
}
void GeometryApp::setup()
{
// Initialize variables.
mPrimitiveSelected = mPrimitiveCurrent = TORUS;
mQualitySelected = mQualityCurrent = HIGH;
mViewMode = SHADED;
mLastMouseDownTime = 0;
mShowColors = false;
mShowNormals = false;
mShowGrid = true;
mEnableFaceFulling = false;
mSubdivision = 1;
// Load the textures.
gl::Texture::Format fmt;
fmt.setAutoInternalFormat();
fmt.setWrap( GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE );
mTexture = gl::Texture::create( loadImage( loadAsset("stripes.jpg") ), fmt );
// Setup the camera.
mCamera.setEyePoint( normalize( vec3( 3, 3, 6 ) ) * 5.0f );
mCamera.setCenterOfInterestPoint( mCameraCOI );
// Load and compile the shaders.
createPhongShader();
createWireframeShader();
// Create the meshes.
createGrid();
createPrimitive();
// Enable the depth buffer.
gl::enableDepthRead();
gl::enableDepthWrite();
// Create a parameter window, so we can toggle stuff.
createParams();
}
void GeometryApp::update()
{
// If another primitive or quality was selected, reset the subdivision and recreate the primitive.
if( mPrimitiveCurrent != mPrimitiveSelected || mQualitySelected != mQualityCurrent ) {
mSubdivision = 1;
mPrimitiveCurrent = mPrimitiveSelected;
mQualityCurrent = mQualitySelected;
createPrimitive();
}
// After creating a new primitive, gradually move the camera to get a good view.
if( mRecenterCamera ) {
float distance = glm::distance( mCamera.getEyePoint(), mCameraCOI );
mCamera.setEyePoint( mCameraCOI - lerp( distance, 5.0f, 0.1f ) * mCamera.getViewDirection() );
mCamera.setCenterOfInterestPoint( lerp( mCamera.getCenterOfInterestPoint(), mCameraCOI, 0.25f) );
}
}
void GeometryApp::draw()
{
// Prepare for drawing.
gl::clear( Color::black() );
gl::setMatrices( mCamera );
// Draw the grid.
if( mShowGrid && mGrid ) {
gl::ScopedGlslProg scopedGlslProg( gl::context()->getStockShader( gl::ShaderDef().color() ) );
mGrid->draw();
}
if( mPrimitive ) {
gl::ScopedTextureBind scopedTextureBind( mTexture );
// Rotate it slowly around the y-axis.
gl::pushModelView();
gl::rotate( float( getElapsedSeconds() / 5 ), 0.0f, 1.0f, 0.0f );
// Draw the normals.
if( mShowNormals && mPrimitiveNormalLines ) {
gl::ScopedColor colorScope( Color( 1, 1, 0 ) );
mPrimitiveNormalLines->draw();
}
// Draw the primitive.
gl::ScopedColor colorScope( Color( 0.7f, 0.5f, 0.3f ) );
// (If transparent, render the back side first).
if( mViewMode == WIREFRAME ) {
gl::enableAlphaBlending();
gl::enable( GL_CULL_FACE );
gl::cullFace( GL_FRONT );
mWireframeShader->uniform( "uBrightness", 0.5f );
mPrimitiveWireframe->draw();
}
// (Now render the front side.)
if( mViewMode == WIREFRAME ) {
gl::cullFace( GL_BACK );
mWireframeShader->uniform( "uBrightness", 1.0f );
mPrimitiveWireframe->draw();
gl::disable( GL_CULL_FACE );
gl::disableAlphaBlending();
}
else
mPrimitive->draw();
// Done.
gl::popModelView();
}
// Render the parameter window.
#if ! defined( CINDER_GL_ES )
if( mParams )
mParams->draw();
#endif
}
void GeometryApp::mouseDown( MouseEvent event )
{
mRecenterCamera = false;
mMayaCam.setCurrentCam( mCamera );
mMayaCam.mouseDown( event.getPos() );
if( getElapsedSeconds() - mLastMouseDownTime < 0.2f ) {
mPrimitiveSelected = static_cast<Primitive>( static_cast<int>(mPrimitiveSelected) + 1 );
createPrimitive();
}
mLastMouseDownTime = getElapsedSeconds();
}
void GeometryApp::mouseDrag( MouseEvent event )
{
mMayaCam.mouseDrag( event.getPos(), event.isLeftDown(), event.isMiddleDown(), event.isRightDown() );
mCamera = mMayaCam.getCamera();
}
void GeometryApp::resize()
{
mCamera.setAspectRatio( getWindowAspectRatio() );
if(mWireframeShader)
mWireframeShader->uniform( "uViewportSize", vec2( getWindowSize() ) );
}
void GeometryApp::keyDown( KeyEvent event )
{
switch( event.getCode() ) {
case KeyEvent::KEY_SPACE:
mPrimitiveSelected = static_cast<Primitive>( static_cast<int>(mPrimitiveSelected) + 1 );
createPrimitive();
break;
case KeyEvent::KEY_c:
mShowColors = ! mShowColors;
createPrimitive();
break;
case KeyEvent::KEY_n:
mShowNormals = ! mShowNormals;
break;
case KeyEvent::KEY_g:
mShowGrid = ! mShowGrid;
break;
case KeyEvent::KEY_q:
mQualitySelected = Quality( (int)( mQualitySelected + 1 ) % 3 );
break;
case KeyEvent::KEY_w:
if(mViewMode == WIREFRAME)
mViewMode = SHADED;
else
mViewMode = WIREFRAME;
break;
case KeyEvent::KEY_RETURN:
CI_LOG_V( "reload" );
createPhongShader();
createPrimitive();
break;
}
}
void GeometryApp::createParams()
{
#if ! defined( CINDER_GL_ES )
std::string primitives[] = { "Capsule", "Cone", "Cube", "Cylinder", "Helix", "Icosahedron", "Icosphere", "Sphere", "Teapot", "Torus", "Plane" };
std::string qualities[] = { "Low", "Default", "High" };
std::string viewmodes[] = { "Shaded", "Wireframe" };
mParams = params::InterfaceGl::create( getWindow(), "Geometry Demo", toPixels( ivec2( 300, 200 ) ) );
mParams->setOptions( "", "valueswidth=160 refresh=0.1" );
mParams->addParam( "Primitive", vector<string>( primitives, primitives + 11 ), (int*) &mPrimitiveSelected );
mParams->addParam( "Quality", vector<string>( qualities, qualities + 3 ), (int*) &mQualitySelected );
mParams->addParam( "Viewing Mode", vector<string>( viewmodes, viewmodes + 2 ), (int*) &mViewMode );
mParams->addSeparator();
mParams->addParam( "Subdivision", &mSubdivision ).min( 1 ).max( 5 ).updateFn( [this] { createPrimitive(); } );
mParams->addSeparator();
mParams->addParam( "Show Grid", &mShowGrid );
mParams->addParam( "Show Normals", &mShowNormals );
mParams->addParam( "Show Colors", &mShowColors ).updateFn( [this] { createPrimitive(); } );
mParams->addParam( "Face Culling", &mEnableFaceFulling ).updateFn( [this] { gl::enableFaceCulling( mEnableFaceFulling ); } );
#endif
}
void GeometryApp::createGrid()
{
mGrid = gl::VertBatch::create( GL_LINES );
mGrid->begin( GL_LINES );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( -10.0f, 0.0f, 0.0f );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(1, 0, 0) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(1, 0, 0) ); mGrid->vertex( 20.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 1, 0) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 1, 0) ); mGrid->vertex( 0.0f, 20.0f, 0.0f );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( 0.0f, 0.0f, -10.0f );
mGrid->color( Color(0.25f, 0.25f, 0.25f) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 0, 1) ); mGrid->vertex( 0.0f, 0.0f, 0.0f );
mGrid->color( Color(0, 0, 1) ); mGrid->vertex( 0.0f, 0.0f, 20.0f );
for( int i = -10; i <= 10; ++i ) {
if( i == 0 )
continue;
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->color( Color(0.25f, 0.25f, 0.25f) );
mGrid->vertex( float(i), 0.0f, -10.0f );
mGrid->vertex( float(i), 0.0f, +10.0f );
mGrid->vertex( -10.0f, 0.0f, float(i) );
mGrid->vertex( +10.0f, 0.0f, float(i) );
}
mGrid->end();
}
void GeometryApp::createPrimitive()
{
geom::SourceRef primitive;
std::string name;
switch( mPrimitiveCurrent ) {
default:
mPrimitiveSelected = CAPSULE;
case CAPSULE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Capsule( geom::Capsule() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Capsule( geom::Capsule().subdivisionsAxis( 6 ).subdivisionsHeight( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Capsule( geom::Capsule().subdivisionsAxis( 60 ).subdivisionsHeight( 20 ) ) ); break;
}
break;
case CONE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Cone() ); break;
case LOW: primitive = geom::SourceRef( new geom::Cone( geom::Cone().subdivisionsAxis( 6 ).subdivisionsHeight( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Cone( geom::Cone().subdivisionsAxis( 60 ).subdivisionsHeight( 60 ) ) ); break;
}
break;
case CUBE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Cube( geom::Cube() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Cube( geom::Cube().subdivisions( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Cube( geom::Cube().subdivisions( 10 ) ) ); break;
}
break;
case CYLINDER:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Cylinder( geom::Cylinder() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Cylinder( geom::Cylinder().subdivisionsAxis( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Cylinder( geom::Cylinder().subdivisionsAxis( 60 ).subdivisionsHeight( 20 ) ) ); break;
}
break;
case HELIX:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Helix( geom::Helix() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Helix( geom::Helix().subdivisionsHeight( 12 ).subdivisionsHeight( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Helix( geom::Helix().subdivisionsHeight( 60 ).subdivisionsHeight( 60 ) ) ); break;
}
break;
case ICOSAHEDRON:
primitive = geom::SourceRef( new geom::Icosahedron( geom::Icosahedron() ) );
break;
case ICOSPHERE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Icosphere( geom::Icosphere() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Icosphere( geom::Icosphere().subdivisions( 1 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Icosphere( geom::Icosphere().subdivisions( 5 ) ) ); break;
}
break;
case SPHERE:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Sphere( geom::Sphere() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Sphere( geom::Sphere().subdivisions( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Sphere( geom::Sphere().subdivisions( 60 ) ) ); break;
}
break;
case TEAPOT:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Teapot( geom::Teapot() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Teapot( geom::Teapot().subdivisions( 2 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Teapot( geom::Teapot().subdivisions( 12 ) ) ); break;
}
break;
case TORUS:
switch(mQualityCurrent) {
case DEFAULT: primitive = geom::SourceRef( new geom::Torus( geom::Torus() ) ); break;
case LOW: primitive = geom::SourceRef( new geom::Torus( geom::Torus().subdivisionsAxis( 12 ).subdivisionsHeight( 6 ) ) ); break;
case HIGH: primitive = geom::SourceRef( new geom::Torus( geom::Torus().subdivisionsAxis( 60 ).subdivisionsHeight( 60 ) ) ); break;
}
break;
case PLANE:
ivec2 numSegments;
switch( mQualityCurrent ) {
case DEFAULT: numSegments = ivec2( 10, 10 ); break;
case LOW: numSegments = ivec2( 2, 2 ); break;
case HIGH: numSegments = ivec2( 100, 100 ); break;
}
auto plane = geom::Plane().subdivisions( numSegments );
// plane.normal( vec3( 0, 0, 1 ) ); // change the normal angle of the plane
// plane.axes( vec3( 0.70710678118, -0.70710678118, 0 ), vec3( 0.70710678118, 0.70710678118, 0 ) ); // dictate plane u/v axes directly
// plane.subdivisions( ivec2( 3, 10 ) ).size( vec2( 0.5f, 2.0f ) ).origin( vec3( 0, 1.0f, 0 ) ).normal( vec3( 0, 0, 1 ) ); // change the size and origin so that it is tall and thin, above the y axis.
primitive = geom::SourceRef( new geom::Plane( plane ) );
break;
}
// The purpose of the TriMesh is to capture a bounding box; without that need we could just instantiate the Batch directly using primitive
TriMesh::Format fmt = TriMesh::Format().positions().normals().texCoords();
if( mShowColors && primitive->getAvailableAttribs().count( geom::COLOR ) > 0 )
fmt.colors();
TriMesh mesh( *primitive, fmt );
AxisAlignedBox3f bbox = mesh.calcBoundingBox();
mCameraCOI = mesh.calcBoundingBox().getCenter();
mRecenterCamera = true;
if( mSubdivision > 1 )
mesh.subdivide( mSubdivision );
if( mPhongShader )
mPrimitive = gl::Batch::create( mesh, mPhongShader );
if( mWireframeShader )
mPrimitiveWireframe = gl::Batch::create( mesh, mWireframeShader );
vec3 size = bbox.getMax() - bbox.getMin();
float scale = std::max( std::max( size.x, size.y ), size.z ) / 25.0f;
mPrimitiveNormalLines = gl::Batch::create( geom::VertexNormalLines( mesh, scale ), gl::getStockShader( gl::ShaderDef().color() ) );
getWindow()->setTitle( "Geometry - " + to_string( mesh.getNumVertices() ) + " vertices" );
}
void GeometryApp::createPhongShader()
{
try {
#if defined( CINDER_GL_ES )
mPhongShader = gl::GlslProg::create( loadAsset( "phong_es2.vert" ), loadAsset( "phong_es2.frag" ) );
#else
mPhongShader = gl::GlslProg::create( loadAsset( "phong.vert" ), loadAsset( "phong.frag" ) );
#endif
}
catch( Exception &exc ) {
CI_LOG_E( "error loading phong shader: " << exc.what() );
}
}
void GeometryApp::createWireframeShader()
{
#if ! defined( CINDER_GL_ES )
try {
auto format = gl::GlslProg::Format()
.vertex( loadAsset( "wireframe.vert" ) )
.geometry( loadAsset( "wireframe.geom" ) )
.fragment( loadAsset( "wireframe.frag" ) );
mWireframeShader = gl::GlslProg::create( format );
}
catch( Exception &exc ) {
CI_LOG_E( "error loading wireframe shader: " << exc.what() );
}
#endif // ! defined( CINDER_GL_ES )
}
CINDER_APP_NATIVE( GeometryApp, RendererGl )
|
/* RTcmix - Copyright (C) 2004 The RTcmix Development Team
See ``AUTHORS'' for a list of contributors. See ``LICENSE'' for
the license to this software and for a DISCLAIMER OF ALL WARRANTIES.
*/
/* A revised MinC, supporting lists, types and other fun things.
Based heavily on the classic cmix version by Lars Graf.
Doug Scott added the '#' and '//' comment parsing.
John Gibson <johgibso at indiana dot edu>, 1/20/04
*/
/* This file holds the intermediate tree representation. */
#undef DEBUG
#include "minc_internal.h"
#include "handle.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>
extern "C" {
void yyset_lineno(int line_number);
int yyget_lineno(void);
};
/* We maintain a stack of MAXSTACK lists, which we access when forming
user lists (i.e., {1, 2, "foo"}) and function argument lists. Each
element of this stack is a list, allocated and freed by push_list and
pop_list. <list> is an array of MincListElem structures, each having
a type and a value, which is encoded in a MincValue union. Nested lists
and lists of mixed types are possible.
*/
static MincListElem *sMincList;
static int sMincListLen;
static MincListElem *list_stack[MAXSTACK];
static int list_len_stack[MAXSTACK];
static int list_stack_ptr;
static int sArgListLen; // number of arguments passed to a user-declared function
static int sArgListIndex; // used to walk passed-in args for user-declared functions
static bool inCalledFunctionArgList = false;
static const char *sCalledFunction;
static int sFunctionCallDepth = 0; // level of actively-executing function calls
static bool inFunctionCall() { return sFunctionCallDepth > 0; }
#undef DEBUG_TRACE
#if defined(DEBUG_TRACE)
class Trace {
public:
Trace(const char *func) : mFunc(func) {
rtcmix_print("%s%s -->\n", spaces, mFunc);
++sTraceDepth;
for (int n =0; n<sTraceDepth*3; ++n) { spaces[n] = ' '; }
spaces[sTraceDepth*3] = '\0';
}
static char *getBuf() { return sMsgbuf; }
static void printBuf() { rtcmix_print("%s%s", spaces, sMsgbuf); }
~Trace() {
--sTraceDepth;
for (int n =0; n<sTraceDepth*3; ++n) { spaces[n] = ' '; }
spaces[sTraceDepth*3] = '\0';
rtcmix_print("%s<-- %s\n", spaces, mFunc);
}
private:
static char sMsgbuf[];
const char *mFunc;
static int sTraceDepth;
static char spaces[];
};
char Trace::sMsgbuf[256];
int Trace::sTraceDepth = 0;
char Trace::spaces[128];
#define ENTER() Trace __trace__(__FUNCTION__)
#define TPRINT(...) do { snprintf(Trace::getBuf(), 256, __VA_ARGS__); Trace::printBuf(); } while(0)
#else
#define ENTER()
#define TPRINT(...)
#endif
#undef DEBUG_MEMORY
#ifdef DEBUG_MEMORY
static int numTrees = 0;
#endif
static const char *s_NodeKinds[] = {
"NodeZero",
"NodeSeq",
"NodeStore",
"NodeList",
"NodeListElem",
"NodeEmptyListElem",
"NodeSubscriptRead",
"NodeSubscriptWrite",
"NodeOpAssign",
"NodeName",
"NodeAutoName",
"NodeConstf",
"NodeString",
"NodeFuncDef",
"NodeArgList",
"NodeArgListElem",
"NodeRet",
"NodeFuncSeq",
"NodeCall",
"NodeAnd",
"NodeOr",
"NodeOperator",
"NodeUnaryOperator",
"NodeNot",
"NodeRelation",
"NodeIf",
"NodeWhile",
"NodeFor",
"NodeIfElse",
"NodeDecl",
"NodeFuncDecl",
"NodeBlock",
"NodeNoop"
};
static const char *s_OpKinds[] = {
"ILLEGAL",
"ILLEGAL",
"+",
"-",
"*",
"/",
"%",
"^",
"-",
"==",
"!=",
"<",
">",
"<=",
">="
};
static const char *printNodeKind(NodeKind k)
{
return s_NodeKinds[k];
}
static const char *printOpKind(OpKind k)
{
return s_OpKinds[k];
}
/* prototypes for local functions */
static int cmp(MincFloat f1, MincFloat f2);
static Tree node(OpKind op, NodeKind kind);
static void push_list(void);
static void pop_list(void);
static void copy_tree_tree(Tree tpdest, Tree tpsrc);
static void copy_sym_tree(Tree tpdest, Symbol *src);
static void copy_tree_sym(Symbol *dest, Tree tpsrc);
static void copy_tree_listelem(MincListElem *edest, Tree tpsrc);
static void copy_listelem_tree(Tree tpdest, MincListElem *esrc);
static void copy_listelem_elem(MincListElem *edest, MincListElem *esrc);
/* floating point comparisons:
f1 < f2 ==> -1
f1 == f2 ==> 0
f1 > f2 ==> 1
*/
static int
cmp(MincFloat f1, MincFloat f2)
{
if (fabs((double) f1 - (double) f2) < EPSILON) {
/* printf("cmp=%g %g %g \n",f1,f2,fabs(f1-f2)); */
return 0;
}
if ((f1 - f2) > EPSILON) {
/* printf("cmp > %g %g %g \n",f1,f2,fabs(f1-f2)); */
return 1;
}
if ((f2 - f1) > EPSILON) {
/* printf("cmp <%g %g %g \n",f1,f2,fabs(f1-f2)); */
return -1;
}
return 0;
}
static MincList *
newList(int len)
{
ENTER();
MincList *list = (MincList *) emalloc(sizeof(MincList));
if (list) {
list->len = len;
list->refcount = 0;
if (len > 0) {
list->data = (MincListElem *) emalloc(len * sizeof(MincListElem));
if (!list->data) {
efree(list);
list = NULL;
}
else {
memset(list->data, 0, len * sizeof(MincListElem));
}
}
else
list->data = NULL;
TPRINT("newList: %p alloc'd at len %d\n", list, sMincListLen);
}
return list;
}
static void
resizeList(MincList *list, int newLen)
{
int i;
list->data = (MincListElem *) realloc(list->data, sizeof(MincListElem) * newLen);
for (i = list->len; i < newLen; i++) {
list->data[i].type = MincFloatType;
list->data[i].val.number = 0.0;
}
list->len = newLen;
}
/* ========================================================================== */
/* Tree nodes */
static Tree
node(OpKind op, NodeKind kind)
{
Tree tp;
tp = (Tree) emalloc(sizeof(struct tree));
if (tp == NULL)
return NULL;
tp->op = op;
tp->kind = kind;
tp->type = MincVoidType;
tp->u.child[0] = NULL; /* these clear entire <u> union */
tp->u.child[1] = NULL;
tp->u.child[2] = NULL;
tp->u.child[3] = NULL;
tp->v.list = NULL;
tp->name = NULL;
tp->lineno = yyget_lineno();
#ifdef DEBUG_MEMORY
++numTrees;
TPRINT("[%d trees in existence]\n", numTrees);
#endif
return tp;
}
Tree
tnoop()
{
Tree tp = node(OpFree, NodeNoop);
TPRINT("tnoop => NodeNoop %p\n", tp);
return tp;
}
Tree
tseq(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeSeq);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tseq (%p, %p) => NodeSeq %p\n", e1, e2, tp);
return tp;
}
Tree
top(OpKind op, Tree e1, Tree e2)
{
Tree tp = node(op, NodeOperator);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("top (%d, %p, %p) => NodeOperator %p\n", op, e1, e2, tp);
return tp;
}
Tree
tunop(OpKind op, Tree e1)
{
Tree tp = node(op, NodeUnaryOperator);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
TPRINT("tunop (%d, %p) => NodeUnaryOperator %p\n", op, e1, tp);
return tp;
}
/* store a value into a variable */
Tree
tstore(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeStore);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tstore (%p, %p) => NodeStore %p\n", e1, e2, tp);
return tp;
}
/* like tstore, but modify value before storing into variable */
Tree
topassign(Tree e1, Tree e2, OpKind op)
{
Tree tp = node(op, NodeOpAssign);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("topassign, op=%d (%p, %p) => NodeOpAssign %p\n", op, e1, e2, tp);
return tp;
}
/* looks up symbol name and get the symbol.
converts symbol table entry into tree
or initialize tree node to a symbol entry
*/
Tree
tname(const char *symbolName)
{
Tree tp = node(OpFree, NodeName);
if (tp == NULL)
return NULL;
tp->name = symbolName;
TPRINT("tname ('%s') => NodeName %p\n", symbolName, tp);
return tp;
}
/* looks up symbol name and get the symbol, and auto-declares it if not found
converts symbol table entry into tree
or initialize tree node to a symbol entry
*/
Tree
tautoname(const char *symbolName)
{
Tree tp = node(OpFree, NodeAutoName);
if (tp == NULL)
return NULL;
tp->name = symbolName;
TPRINT("tautoname ('%s') => NodeAutoName %p\n", symbolName, tp);
return tp;
}
Tree
tstring(const char *str)
{
Tree tp = node(OpFree, NodeString);
if (tp == NULL)
return NULL;
tp->u.string = str;
TPRINT("tstring ('%s') => NodeString %p\n", str, tp);
return tp;
}
Tree
tconstf(MincFloat num)
{
Tree tp = node(OpFree, NodeConstf);
if (tp == NULL)
return NULL;
tp->u.number = num;
TPRINT("tconstf (%f) => NodeConstf %p\n", num, tp);
return tp;
}
Tree
targlistelem(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeArgListElem);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // previous NodeArgListElem
tp->u.child[1] = e2; // payload (NodeDecl for arg)
TPRINT("targlistelem (%p, %p) => NodeArgListElem %p\n", e1, e2, tp);
return tp;
}
Tree
targlist(Tree e1)
{
Tree tp = node(OpFree, NodeArgList);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // tail of NodeArgListElem linked list
TPRINT("targlist (%p) => NodeArgList %p\n", e1, tp);
return tp;
}
Tree
treturn(Tree e1)
{
Tree tp = node(OpFree, NodeRet);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // Node containing RHS for return
TPRINT("treturn (%p) => NodeRet %p\n", e1, tp);
return tp;
}
Tree tfuncseq(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeFuncSeq);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tfuncseq (%p, %p) => NodeFuncSeq %p\n", e1, e2, tp);
return tp;
}
Tree
tfdef(Tree e1, Tree e2, Tree e3)
{
Tree tp = node(OpFree, NodeFuncDef);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // Lookup node
tp->u.child[1] = e2; // NodeArgList (argument symbol decls)
tp->u.child[2] = e3; // NodeFuncSeq function body (statements), which returns value
// Right now, this last is handed to the Symbol and
// then NULL'd here in exct()
TPRINT("tfdef (%p, %p, %p) => NodeFuncDef %p\n", e1, e2, e3, tp);
return tp;
}
Tree
tcall(Tree args, const char *funcname)
{
Tree tp = node(OpFree, NodeCall);
if (tp == NULL)
return NULL;
tp->name = funcname;
tp->u.child[0] = args;
TPRINT("tcall (%p, '%s') => NodeCall %p\n", args, funcname, tp);
return tp;
}
Tree
tcand(Tree test1, Tree test2)
{
Tree tp = node(OpFree, NodeAnd);
if (tp == NULL)
return NULL;
tp->u.child[0] = test1;
tp->u.child[1] = test2;
TPRINT("tcand (%p, %p) => NodeAnd %p\n", test1, test2, tp);
return tp;
}
Tree
tcor(Tree test1, Tree test2)
{
Tree tp = node(OpFree, NodeOr);
if (tp == NULL)
return NULL;
tp->u.child[0] = test1;
tp->u.child[1] = test2;
TPRINT("tcor (%p, %p) => NodeOr %p\n", test1, test2, tp);
return tp;
}
Tree
tnot(Tree test1)
{
Tree tp = node(OpFree, NodeNot);
if (tp == NULL)
return NULL;
tp->u.child[0] = test1;
TPRINT("tnot (%p) => NodeNot %p\n", test1, tp);
return tp;
}
Tree
trel(OpKind op, Tree e1, Tree e2)
{
Tree tp = node(op, NodeRelation);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("trel (%d, %p, %p) => NodeRelation %p\n", op, e1, e2, tp);
return tp;
}
/* Create list: either an argument list or a user array. Why do we
not separate these two things? Because at the time when we need
to push the list elements onto a stack, we don't know whether they
form part of a user list or an argument list.
*/
Tree
tlist(Tree e1)
{
Tree tp = node(OpFree, NodeList);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // tail of NodeListElem linked list
TPRINT("tlist (%p) => NodeList %p\n", e1, tp);
return tp;
}
Tree
tlistelem(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeListElem);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // previous elem
tp->u.child[1] = e2; // payload (contents of exp)
TPRINT("tlistelem (%p, %p) => NodeListElem %p\n", e1, e2, tp);
return tp;
}
Tree
temptylistelem()
{
Tree tp = node(OpFree, NodeEmptyListElem);
TPRINT("temptylistelem => NodeEmptyListElem %p\n", tp);
return tp;
}
Tree
tsubscriptread(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeSubscriptRead);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tsubscriptread (%p, %p) => NodeSubscriptRead %p\n", e1, e2, tp);
return tp;
}
Tree
tsubscriptwrite(Tree e1, Tree e2, Tree e3)
{
Tree tp = node(OpFree, NodeSubscriptWrite);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
tp->u.child[2] = e3;
TPRINT("tsubscriptwrite (%p, %p, %p) => NodeSubscriptWrite %p\n", e1, e2, e3, tp);
return tp;
}
Tree
tif(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeIf);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tif (%p, %p) => NodeIf %p\n", e1, e2, tp);
return tp;
}
Tree
tifelse(Tree e1, Tree e2, Tree e3)
{
Tree tp = node(OpFree, NodeIfElse);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
tp->u.child[2] = e3;
TPRINT("tifelse (%p, %p, %p) => NodeIfElse %p\n", e1, e2, e3, tp);
return tp;
}
Tree
tfor(Tree e1, Tree e2, Tree e3, Tree e4)
{
Tree tp = node(OpFree, NodeFor);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
tp->u.child[2] = e3;
tp->u.child[3] = e4;
TPRINT("tfor (%p, %p, %p, <e4>) => NodeFor %p\n", e1, e2, e3, tp);
return tp;
}
Tree
twhile(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeWhile);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("twhile (%p, %p) => NodeWhile %p\n", e1, e2, tp);
return tp;
}
Tree tdecl(const char *name, MincDataType type)
{
Tree tp = node(OpFree, NodeDecl);
if (tp == NULL)
return NULL;
tp->name = name;
tp->type = type;
TPRINT("tdecl ('%s') => NodeDecl %p\n", name, tp);
return tp;
}
Tree tfdecl(const char *name, MincDataType type)
{
Tree tp = node(OpFree, NodeFuncDecl);
if (tp == NULL)
return NULL;
tp->name = name;
tp->type = type;
TPRINT("tfdecl ('%s') => NodeFuncDecl %p\n", name, tp);
return tp;
}
Tree tblock(Tree e1)
{
Tree tp = node(OpFree, NodeBlock);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
TPRINT("tblock (%p) => NodeBlock %p\n", e1, tp);
return tp;
}
/* ========================================================================== */
/* Operators */
/* ---------------------------------------------------------- do_op_string -- */
static void
do_op_string(Tree tp, const char *str1, const char *str2, OpKind op)
{
ENTER();
char *s;
unsigned long len;
switch (op) {
case OpPlus: /* concatenate */
len = (strlen(str1) + strlen(str2)) + 1;
s = (char *) emalloc(sizeof(char) * len);
if (s == NULL)
return;
strcpy(s, str1);
strcat(s, str2);
tp->v.string = s;
// printf("str1=%s, str2=%s len=%d, s=%s\n", str1, str2, len, s);
break;
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
case OpNeg:
minc_warn("unsupported operation on a string");
return;
default:
minc_internal_error("invalid string operator");
break;
}
tp->type = MincStringType;
}
/* ------------------------------------------------------------- do_op_num -- */
static void
do_op_num(Tree tp, const MincFloat val1, const MincFloat val2, OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
tp->v.number = val1 + val2;
break;
case OpMinus:
tp->v.number = val1 - val2;
break;
case OpMul:
tp->v.number = val1 * val2;
break;
case OpDiv:
tp->v.number = val1 / val2;
break;
case OpMod:
tp->v.number = (MincFloat) ((long) val1 % (long) val2);
break;
case OpPow:
tp->v.number = pow(val1, val2);
break;
case OpNeg:
tp->v.number = -val1; /* <val2> ignored */
break;
default:
minc_internal_error("invalid numeric operator");
break;
}
tp->type = MincFloatType;
}
/* ------------------------------------------------------ do_op_handle_num -- */
static void
do_op_handle_num(Tree tp, const MincHandle val1, const MincFloat val2,
OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
tp->v.handle = minc_binop_handle_float(val1, val2, op);
ref_handle(tp->v.handle);
break;
case OpNeg:
tp->v.handle = minc_binop_handle_float(val1, -1.0, OpMul); // <val2> ignored
ref_handle(tp->v.handle);
break;
default:
minc_internal_error("invalid operator for handle and number");
break;
}
tp->type = MincHandleType;
}
/* ------------------------------------------------------ do_op_num_handle -- */
static void
do_op_num_handle(Tree tp, const MincFloat val1, const MincHandle val2,
OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
tp->v.handle = minc_binop_float_handle(val1, val2, op);
ref_handle(tp->v.handle);
break;
case OpNeg:
/* fall through */
default:
minc_internal_error("invalid operator for handle and number");
break;
}
tp->type = MincHandleType;
}
/* --------------------------------------------------- do_op_handle_handle -- */
static void
do_op_handle_handle(Tree tp, const MincHandle val1, const MincHandle val2,
OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
tp->v.handle = minc_binop_handles(val1, val2, op);
ref_handle(tp->v.handle);
break;
case OpNeg:
default:
minc_internal_error("invalid binary handle operator");
break;
}
if (tp->v.handle)
tp->type = MincHandleType;
}
/* ---------------------------------------------------- do_op_list_iterate -- */
/* Iterate over <child>'s list, performing the operation specified by <op>,
using the scalar <val>, for each list element. Store the result into a
new list for <tp>, so that child's list is unchanged.
*/
static void
do_op_list_iterate(Tree tp, Tree child, const MincFloat val, const OpKind op)
{
ENTER();
int i;
MincListElem *dest;
const MincList *srcList = child->v.list;
const int len = srcList->len;
MincListElem *src = srcList->data;
MincList *destList = newList(len);
if (destList == NULL)
return;
dest = destList->data;
assert(len >= 0);
switch (op) {
case OpPlus:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number + val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpMinus:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number - val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpMul:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number * val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpDiv:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number / val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpMod:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = (MincFloat) ((long) src[i].val.number
% (long) val);
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpPow:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = (MincFloat) pow((double) src[i].val.number,
(double) val);
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpNeg:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = -src[i].val.number; /* <val> ignored */
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
default:
for (i = 0; i < len; i++)
dest[i].val.number = 0.0;
minc_internal_error("invalid list operator");
break;
}
assert(tp->type == MincVoidType); // are we ever overwriting these?
tp->type = MincListType;
assert(tp->v.list == NULL);
tp->v.list = destList;
TPRINT("do_op_list_iterate: list %p refcount %d -> %d\n", destList, destList->refcount, destList->refcount+1);
++destList->refcount;
}
/* --------------------------------------------------------- exct_operator -- */
static void
exct_operator(Tree tp, OpKind op)
{
ENTER();
Tree child0, child1;
child0 = exct(tp->u.child[0]);
child1 = exct(tp->u.child[1]);
switch (child0->type) {
case MincFloatType:
switch (child1->type) {
case MincFloatType:
do_op_num(tp, child0->v.number, child1->v.number, op);
break;
case MincStringType:
{
char buf[64];
snprintf(buf, 64, "%g", child0->v.number);
do_op_string(tp, buf, child1->v.string, op);
}
break;
case MincHandleType:
do_op_num_handle(tp, child0->v.number, child1->v.handle, op);
break;
case MincListType:
/* Check for nonsensical ops. */
if (op == OpMinus)
minc_warn("can't subtract a list from a number");
else if (op == OpDiv)
minc_warn("can't divide a number by a list");
else
do_op_list_iterate(tp, child1, child0->v.number, op);
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
case MincStringType:
switch (child1->type) {
case MincFloatType:
{
char buf[64];
snprintf(buf, 64, "%g", child1->v.number);
do_op_string(tp, child0->v.string, buf, op);
}
break;
case MincStringType:
do_op_string(tp, child0->v.string, child1->v.string, op);
break;
case MincHandleType:
minc_warn("can't operate on a string and a handle");
break;
case MincListType:
minc_warn("can't operate on a string and a list");
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
case MincHandleType:
switch (child1->type) {
case MincFloatType:
do_op_handle_num(tp, child0->v.handle, child1->v.number, op);
break;
case MincStringType:
minc_warn("can't operate on a string and a handle");
break;
case MincHandleType:
do_op_handle_handle(tp, child0->v.handle, child1->v.handle, op);
break;
case MincListType:
minc_warn("can't operate on a list and a handle");
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
case MincListType:
switch (child1->type) {
case MincFloatType:
do_op_list_iterate(tp, child0, child1->v.number, op);
break;
case MincStringType:
minc_warn("can't operate on a string");
break;
case MincHandleType:
minc_warn("can't operate on a handle");
break;
case MincListType:
minc_warn("can't operate on two lists");
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
default:
minc_internal_error("operator %s: invalid lhs type: %s", printOpKind(op), MincTypeName(child0->type));
break;
}
}
/* --------------------------------------------------------- exct_relation -- */
static void
exct_relation(Tree tp)
{
ENTER();
Tree tp0 = exct(tp->u.child[0]);
Tree tp1 = exct(tp->u.child[1]);
tp->type = MincFloatType;
if (tp0->type != tp1->type) {
minc_warn("operator %s: attempt to compare variables having different types", printOpKind(tp->op));
tp->v.number = 0.0;
return;
}
switch (tp->op) {
case OpEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
case MincStringType:
if (strcmp(tp0->v.string, tp1->v.string) == 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpNotEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == 0)
tp->v.number = 0.0;
else
tp->v.number = 1.0;
break;
case MincStringType:
if (strcmp(tp0->v.string, tp1->v.string) == 0)
tp->v.number = 0.0;
else
tp->v.number = 1.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpLess:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == -1)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpGreater:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == 1)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpLessEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) <= 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpGreaterEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) >= 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
default:
minc_internal_error("exct: tried to execute invalid NodeRelation");
break;
}
return;
unsupported_type:
minc_internal_error("operator %s: can't compare this type of object", printOpKind(tp->op));
}
/* --------------------------------------------------------- exct_opassign -- */
static void
exct_opassign(Tree tp, OpKind op)
{
ENTER();
Tree tp0 = exct(tp->u.child[0]);
Tree tp1 = exct(tp->u.child[1]);
if (tp0->u.symbol->type != MincFloatType || tp1->type != MincFloatType) {
minc_warn("can only use '%c=' with numbers",
op == OpPlus ? '+' : (op == OpMinus ? '-'
: (op == OpMul ? '*' : '/')));
//FIXME: Is this correct?
// memcpy(&tp->v, &tp0->u.symbol->v, sizeof(MincValue));
// tp->type = tp0->type;
copy_sym_tree(tp, tp0->u.symbol);
return;
}
switch (tp->op) {
case OpPlus:
tp0->u.symbol->v.number += tp1->v.number;
break;
case OpMinus:
tp0->u.symbol->v.number -= tp1->v.number;
break;
case OpMul:
tp0->u.symbol->v.number *= tp1->v.number;
break;
case OpDiv:
tp0->u.symbol->v.number /= tp1->v.number;
break;
default:
minc_internal_error("exct: tried to execute invalid NodeOpAssign");
break;
}
tp0->u.symbol->type = tp1->type;
tp->v.number = tp0->u.symbol->v.number;
tp->type = tp1->type;
}
/* --------------------------------------------------- exct_subscript_read -- */
static void
exct_subscript_read(Tree tp)
{
ENTER();
exct(tp->u.child[0]); /* lookup target */
exct(tp->u.child[1]);
if (tp->u.child[1]->type == MincFloatType) {
if (tp->u.child[0]->u.symbol->type == MincListType) {
MincListElem elem;
MincFloat fltindex = tp->u.child[1]->v.number;
int index = (int) fltindex;
MincFloat frac = fltindex - index;
MincList *theList = tp->u.child[0]->u.symbol->v.list;
if (theList == NULL) {
minc_die("attempt to index a NULL list");
return;
}
int len = theList->len;
if (len == 0) {
minc_die("attempt to index an empty list");
return;
}
if (fltindex < 0.0) { /* -1 means last element */
if (fltindex <= -2.0)
minc_warn("negative index ... returning last element");
index = len - 1;
fltindex = (MincFloat) index;
}
else if (fltindex > (MincFloat) (len - 1)) {
minc_warn("attempt to index past the end of list ... "
"returning last element");
index = len - 1;
fltindex = (MincFloat) index;
}
elem.type = MincVoidType;
copy_listelem_elem(&elem, &theList->data[index]);
/* do linear interpolation for float items */
if (elem.type == MincFloatType && frac > 0.0 && index < len - 1) {
MincListElem elem2 = theList->data[index + 1];
if (elem2.type == MincFloatType)
tp->v.number = elem.val.number
+ (frac * (elem2.val.number - elem.val.number));
else /* can't interpolate btw. a number and another type */
tp->v.number = elem.val.number;
tp->type = elem.type;
}
else {
copy_listelem_tree(tp, &elem);
}
clear_elem(&elem);
}
else
minc_die("attempt to index a variable that's not a list");
}
else
minc_die("list index must be a number");
}
/* -------------------------------------------------- exct_subscript_write -- */
static void
exct_subscript_write(Tree tp)
{
ENTER();
exct(tp->u.child[0]); /* lookup target */
exct(tp->u.child[1]); /* index */
exct(tp->u.child[2]); /* expression to store */
if (tp->u.child[1]->type == MincFloatType) {
if (tp->u.child[0]->u.symbol->type == MincListType) {
int len = 0;
MincList *theList = tp->u.child[0]->u.symbol->v.list;
MincFloat fltindex = tp->u.child[1]->v.number;
int index = (int) fltindex;
if (fltindex - (MincFloat) index > 0.0)
minc_warn("list index must be integer ... correcting");
if (theList != NULL) {
len = theList->len;
assert(len >= 0); /* NB: okay to have zero-length list */
}
if (index == -1) /* means last element */
index = len > 0 ? len - 1 : 0;
else if (index >= len) {
/* resize list */
int i, newslots, oldlen = len;
newslots = len > 0 ? (index - (len - 1)) : index + 1;
len += newslots;
if (len < 0) {
minc_die("list array subscript exceeds integer size limit!");
}
if (theList == NULL)
tp->u.child[0]->u.symbol->v.list = theList = newList(len);
else
resizeList(theList, len);
TPRINT("exct_subscript_write: MincList %p expanded to len %d\n",
theList->data, len);
// Ref the list if just allocated.
if (theList->refcount == 0)
theList->refcount = 1;
TPRINT("list %p refcount = 1\n", theList);
}
copy_tree_listelem(&theList->data[index], tp->u.child[2]);
assert(theList->data[index].type == tp->u.child[2]->type);
copy_tree_tree(tp, tp->u.child[2]);
}
else
minc_die("attempt to index a variable that's not a list");
}
else
minc_die("list index must be a number");
}
/* ========================================================================== */
/* Tree execution and disposal */
/* ------------------------------------------------------ check_list_count -- */
/* This protects us against a situation that can arise due to our use of
'{' and '}' to delimit both statements and list contents. If you write
the following in a script, it will quickly chew through all available
memory, as it allocates a zero-length block for an empty list on each
iteration.
while (1) {}
This function prevents this from going on for too many thousands of
iterations.
*/
#define MAX_LISTS 50000
static int
check_list_count()
{
static int list_count = 0;
if (++list_count > MAX_LISTS) {
minc_die("Bailing out due to suspected infinite loop on "
"empty code block\n(e.g., \"while (1) {}\").");
return -1;
}
return 0;
}
/* ------------------------------------------------------------------ exct -- */
/* This recursive function interprets the intermediate code.
*/
Tree
exct(Tree tp)
{
if (tp == NULL || was_rtcmix_error())
return NULL;
ENTER();
TPRINT("%s: tp=%p\n", printNodeKind(tp->kind), tp);
if (inFunctionCall() && tp->lineno > 0) {
yyset_lineno(tp->lineno);
}
switch (tp->kind) {
case NodeConstf:
tp->type = MincFloatType;
tp->v.number = tp->u.number;
break;
case NodeString:
tp->type = MincStringType;
tp->v.string = tp->u.string;
break;
case NodeName:
case NodeAutoName:
/* look up the symbol */
if (tp->kind == NodeName) {
tp->u.symbol = lookup(tp->name, AnyLevel);
}
else if (tp->kind == NodeAutoName) {
tp->u.symbol = lookupOrAutodeclare(tp->name, sFunctionCallDepth > 0 ? YES : NO);
}
else {
minc_internal_error("NodeName/NodeAutoName exct: illegal node kind: %d", tp->kind);
}
if (tp->u.symbol) {
TPRINT("NodeName/NodeAutoName: symbol %p\n", tp->u.symbol);
/* also assign the symbol's value into tree's value field */
TPRINT("NodeName/NodeAutoName: copying value from symbol '%s' to us\n", tp->u.symbol->name);
copy_sym_tree(tp, tp->u.symbol);
tp->name = tp->u.symbol->name; // for debugging -- not used
assert(tp->type == tp->u.symbol->type);
}
else {
// FIXME: install id w/ value of 0, then warn??
minc_die("'%s' is not declared", tp->name);
}
break;
case NodeListElem:
TPRINT("NodeListElem exct'ing Tree link %p\n", tp->u.child[0]);
exct(tp->u.child[0]);
if (sMincListLen == MAXDISPARGS) {
minc_die("exceeded maximum number of items for a list");
}
else {
TPRINT("NodeListElem %p evaluating payload child Tree %p\n", tp, tp->u.child[1]);
Tree tmp = exct(tp->u.child[1]);
/* Copy entire MincValue union from expr to tp and to stack. */
TPRINT("NodeListElem %p copying child value into self and stack\n", tp);
copy_tree_tree(tp, tmp);
copy_tree_listelem(&sMincList[sMincListLen], tmp);
assert(sMincList[sMincListLen].type == tmp->type);
sMincListLen++;
TPRINT("NodeListElem: list at level %d now len %d\n", list_stack_ptr, sMincListLen);
}
break;
case NodeEmptyListElem:
/* do nothing */
break;
case NodeList:
push_list();
exct(tp->u.child[0]); /* NB: increments sMincListLen */
{
MincList *theList;
int i;
if (check_list_count() < 0)
return tp;
theList = newList(sMincListLen);
if (theList == NULL)
return NULL;
if (tp->type == MincListType && tp->v.list != NULL)
unref_value_list(&tp->v);
tp->type = MincListType;
tp->v.list = theList;
TPRINT("MincList %p assigned to self\n", theList);
theList->refcount = 1;
TPRINT("MincList refcount = 1\n");
// Copy from stack list into tree list.
for (i = 0; i < sMincListLen; ++i)
copy_listelem_elem(&theList->data[i], &sMincList[i]);
}
pop_list();
break;
case NodeSubscriptRead:
exct_subscript_read(tp);
break;
case NodeSubscriptWrite:
exct_subscript_write(tp);
break;
case NodeCall:
push_list();
{
Symbol *funcSymbol = lookup(tp->name, GlobalLevel);
if (funcSymbol) {
sCalledFunction = tp->name;
/* The function's definition node was stored on the symbol at declaration time.
However, if a function was called on a non-function symbol, the tree will be NULL.
*/
Tree funcDef = funcSymbol->tree;
if (funcDef) {
TPRINT("NodeCall: func def = %p\n", funcDef);
TPRINT("NodeCall: exp decl list = %p\n", tp->u.child[0]);
exct(tp->u.child[0]); // execute arg expression list
push_function_stack();
push_scope();
int savedLineNo, savedScope, savedCallDepth;
Tree temp = NULL;
try {
/* The exp list is copied to the symbols for the function's arg list. */
exct(funcDef->u.child[1]);
savedLineNo = yyget_lineno();
savedScope = current_scope();
++sFunctionCallDepth;
savedCallDepth = sFunctionCallDepth;
TPRINT("NodeCall(%p): executing %s() block node %p, call depth now %d\n",
tp, sCalledFunction, funcDef->u.child[2], savedCallDepth);
temp = exct(funcDef->u.child[2]);
}
catch (Tree returned) { // This catches return statements!
TPRINT("NodeCall(%p) caught %p return stmt throw - restoring call depth %d\n",
tp, returned, savedCallDepth);
temp = returned;
sFunctionCallDepth = savedCallDepth;
restore_scope(savedScope);
}
catch(...) { // Anything else is an error
pop_function_stack();
--sFunctionCallDepth;
throw;
}
--sFunctionCallDepth;
TPRINT("NodeCall: function call depth => %d\n", sFunctionCallDepth);
// restore parser line number
yyset_lineno(savedLineNo);
TPRINT("NodeCall copying def exct results into self\n");
copy_tree_tree(tp, temp);
pop_function_stack();
}
else {
minc_die("'%s' is not a function", funcSymbol->name);
}
sCalledFunction = NULL;
}
else {
exct(tp->u.child[0]);
MincListElem retval;
int result = call_builtin_function(tp->name, sMincList, sMincListLen,
&retval);
if (result < 0) {
result = call_external_function(tp->name, sMincList, sMincListLen,
&retval);
}
copy_listelem_tree(tp, &retval);
assert(tp->type == retval.type);
clear_elem(&retval);
if (result != 0) {
set_rtcmix_error(result); // store fatal error from RTcmix layer (EMBEDDED ONLY)
}
}
}
pop_list();
break;
case NodeStore:
#ifdef ORIGINAL_CODE
/* N.B. Now that symbol lookup is part of tree, this happens in
the NodeName stored as child[0] */
TPRINT("NodeStore(%p): evaluate LHS %p (child 0)\n", tp, tp->u.child[0]);
exct(tp->u.child[0]);
/* evaluate RHS expression */
TPRINT("NodeStore(%p): evaluate RHS (child 1)\n", tp);
exct(tp->u.child[1]);
#else
/* evaluate RHS expression */
TPRINT("NodeStore(%p): evaluate RHS (child 1) FIRST\n", tp);
exct(tp->u.child[1]);
/* N.B. Now that symbol lookup is part of tree, this happens in
the NodeName stored as child[0] */
TPRINT("NodeStore(%p): evaluate LHS %p (child 0)\n", tp, tp->u.child[0]);
exct(tp->u.child[0]);
#endif
TPRINT("NodeStore(%p): copying value from RHS (%p) to LHS's symbol (%p)\n",
tp, tp->u.child[1], tp->u.child[0]->u.symbol);
/* Copy entire MincValue union from expr to id sym and to tp. */
copy_tree_sym(tp->u.child[0]->u.symbol, tp->u.child[1]);
assert(tp->u.child[0]->u.symbol->type == tp->u.child[1]->type);
TPRINT("NodeStore: copying value from RHS (%p) to here (%p)\n", tp->u.child[1], tp);
copy_tree_tree(tp, tp->u.child[1]);
assert(tp->type == tp->u.child[1]->type);
break;
case NodeOpAssign:
exct_opassign(tp, tp->op);
break;
case NodeNot:
tp->type = MincFloatType;
if (cmp(0.0, exct(tp->u.child[0])->v.number) == 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
case NodeAnd:
tp->type = MincFloatType;
tp->v.number = 0.0;
if (cmp(0.0, exct(tp->u.child[0])->v.number) != 0) {
if (cmp(0.0, exct(tp->u.child[1])->v.number) != 0) {
tp->type = MincFloatType;
tp->v.number = 1.0;
}
}
break;
case NodeRelation:
exct_relation(tp);
break; /* switch NodeRelation */
case NodeOperator:
exct_operator(tp, tp->op);
break; /* switch NodeOperator */
case NodeUnaryOperator:
tp->type = MincFloatType;
if (tp->op == OpNeg)
tp->v.number = -exct(tp->u.child[0])->v.number;
break;
case NodeOr:
tp->type = MincFloatType;
tp->v.number = 0.0;
if ((cmp(0.0, exct(tp->u.child[0])->v.number) != 0) ||
(cmp(0.0, exct(tp->u.child[1])->v.number) != 0)) {
tp->v.number = 1.0;
}
break;
case NodeIf:
if (cmp(0.0, exct(tp->u.child[0])->v.number) != 0)
exct(tp->u.child[1]);
break;
case NodeIfElse:
if (cmp(0.0, exct(tp->u.child[0])->v.number) != 0)
exct(tp->u.child[1]);
else
exct(tp->u.child[2]);
break;
case NodeWhile:
while (cmp(0.0, exct(tp->u.child[0])->v.number) != 0)
exct(tp->u.child[1]);
break;
case NodeArgList:
sArgListLen = 0;
sArgListIndex = 0; // reset to walk list
inCalledFunctionArgList = true;
TPRINT("NodeArgList: walking function '%s()' arg decl/copy list\n", sCalledFunction);
exct(tp->u.child[0]);
inCalledFunctionArgList = false;
break;
case NodeArgListElem:
++sArgListLen;
exct(tp->u.child[0]); // work our way to the front of the list
exct(tp->u.child[1]); // run the arg decl
{
// Symbol associated with this function argument
Symbol *argSym = tp->u.child[1]->u.symbol;
if (sMincListLen > sArgListLen) {
minc_die("%s() takes %d arguments but was passed %d!", sCalledFunction, sArgListLen, sMincListLen);
}
else if (sArgListIndex >= sMincListLen) {
minc_warn("%s(): arg '%s' not provided - defaulting to 0", sCalledFunction, argSym->name);
/* Copy zeroed MincValue union to us and then to sym. */
MincListElem zeroElem;
zeroElem.type = argSym->type;
memset(&zeroElem.val, 0, sizeof(MincValue));
copy_listelem_tree(tp, &zeroElem);
copy_tree_sym(argSym, tp);
++sArgListIndex;
}
/* compare stored NodeName with user-passed arg */
else {
// Pre-cached argument value from caller
MincListElem *argValue = &sMincList[sArgListIndex];
bool compatible = false;
switch (argValue->type) {
case MincFloatType:
case MincStringType:
case MincHandleType:
case MincListType:
if (argSym->type != argValue->type) {
minc_die("%s() arg '%s' passed as %s, expecting %s",
sCalledFunction, argSym->name, MincTypeName(argValue->type), MincTypeName(argSym->type));
}
else compatible = true;
break;
default:
assert(argValue->type != MincVoidType);
break;
}
if (compatible) {
/* Copy passed-in arg's MincValue union to us and then to sym. */
copy_listelem_tree(tp, argValue);
copy_tree_sym(argSym, tp);
}
++sArgListIndex;
}
}
break;
case NodeRet:
exct(tp->u.child[0]);
copy_tree_tree(tp, tp->u.child[0]);
assert(tp->type == tp->u.child[0]->type);
TPRINT("NodeRet throwing %p for return stmt\n", tp);
throw tp; // Cool, huh? Throws this node's body out to function's endpoint!
break;
case NodeFuncSeq:
exct(tp->u.child[0]);
exct(tp->u.child[1]);
copy_tree_tree(tp, tp->u.child[1]);
assert(tp->type == tp->u.child[1]->type);
break;
case NodeNoop:
/* do nothing */
break;
case NodeFor:
exct(tp->u.child[0]); /* init */
while (cmp(0.0, exct(tp->u.child[1])->v.number) != 0) { /* condition */
exct(tp->u.child[3]); /* execute block */
exct(tp->u.child[2]); /* prepare for next iteration */
}
break;
case NodeSeq:
exct(tp->u.child[0]);
exct(tp->u.child[1]);
break;
case NodeBlock: // NodeBlock returns void
push_scope();
exct(tp->u.child[0]);
pop_scope();
break;
case NodeDecl:
{
const char *name = tp->name; // as set by NodeDecl creator
TPRINT("-- declaring variable '%s'\n", name);
Symbol *sym = lookup(name, inCalledFunctionArgList ? ThisLevel : AnyLevel);
if (!sym) {
sym = install(name, NO);
sym->type = tp->type;
}
else {
if (sym->scope == current_scope()) {
if (inCalledFunctionArgList) {
minc_die("%s(): argument variable '%s' already used", sCalledFunction, name);
}
minc_warn("variable '%s' redefined - using existing one", name);
}
else {
if (sFunctionCallDepth == 0) {
minc_warn("variable '%s' also defined at enclosing scope", name);
}
sym = install(name, NO);
sym->type = tp->type;
}
}
tp->u.symbol = sym;
}
break;
case NodeFuncDecl:
{
const char *name = tp->name; // as set by NodeDecl creator
TPRINT("-- declaring function '%s'\n", name);
assert(current_scope() == 0); // until I allow nested functions
Symbol *sym = lookup(name, GlobalLevel); // only look at current global level
if (sym == NULL) {
sym = install(name, YES); // all functions global for now
sym->type = tp->type;
tp->u.symbol = sym;
}
else {
minc_die("function %s() is already declared", name);
}
}
break;
case NodeFuncDef:
{
// Look up symbol for function, and bind this FuncDef node to it.
TPRINT("NodeFuncDef: executing lookup node %p\n", tp->u.child[0]);
exct(tp->u.child[0]);
assert(tp->u.child[0]->u.symbol != NULL);
tp->u.child[0]->u.symbol->tree = tp;
}
break;
default:
minc_internal_error("exct: tried to execute invalid node '%s'", printNodeKind(tp->kind));
break;
} /* switch kind */
TPRINT("%s done, tp=%p, %s\n", printNodeKind(tp->kind), tp, MincTypeName(tp->type));
return tp;
}
static void
clear_list(MincListElem *list, int len)
{
ENTER();
int i;
for (i = 0; i < len; ++i) {
clear_elem(&list[i]);
}
}
static void
push_list()
{
ENTER();
if (list_stack_ptr >= MAXSTACK)
minc_die("stack overflow: too many nested function calls");
list_stack[list_stack_ptr] = sMincList;
list_len_stack[list_stack_ptr++] = sMincListLen;
sMincList = (MincListElem *) calloc(MAXDISPARGS, sizeof(MincListElem));
TPRINT("push_list: sMincList=%p at stack level %d, len %d\n", sMincList, list_stack_ptr, sMincListLen);
sMincListLen = 0;
}
static void
pop_list()
{
ENTER();
TPRINT("pop_list: sMincList=%p\n", sMincList);
clear_list(sMincList, MAXDISPARGS);
efree(sMincList);
if (list_stack_ptr == 0)
minc_die("stack underflow");
sMincList = list_stack[--list_stack_ptr];
sMincListLen = list_len_stack[list_stack_ptr];
TPRINT("pop_list: now at sMincList=%p, stack level %d, len %d\n", sMincList, list_stack_ptr, sMincListLen);
}
static void copy_value(MincValue *dest, MincDataType destType,
MincValue *src, MincDataType srcType)
{
ENTER();
if (srcType == MincHandleType && src->handle != NULL) {
ref_handle(src->handle); // ref before unref
}
else if (srcType == MincListType && src->list != NULL) {
#ifdef DEBUG_MEMORY
TPRINT("list %p refcount %d -> %d\n", src->list, src->list->refcount, src->list->refcount+1);
#endif
++src->list->refcount;
}
if (destType == MincHandleType && dest->handle != NULL) {
TPRINT("\toverwriting existing Handle value\n");
unref_handle(dest->handle); // overwriting handle, so unref
}
else if (destType == MincListType) {
TPRINT("\toverwriting existing MincList value\n");
unref_value_list(dest);
}
memcpy(dest, src, sizeof(MincValue));
}
/* This copies a Tree node's value and handles ref counting when necessary */
static void
copy_tree_tree(Tree tpdest, Tree tpsrc)
{
TPRINT("copy_tree_tree(%p, %p)\n", tpdest, tpsrc);
copy_value(&tpdest->v, tpdest->type, &tpsrc->v, tpsrc->type);
if (tpdest->type != MincVoidType && tpsrc->type != tpdest->type) {
minc_warn("Overwriting %s variable '%s' with %s", MincTypeName(tpdest->type), tpdest->name, MincTypeName(tpsrc->type));
}
tpdest->type = tpsrc->type;
TPRINT("dest: ");
print_value(&tpdest->v, tpdest->type);
}
/* This copies a Symbol's value and handles ref counting when necessary */
static void
copy_sym_tree(Tree tpdest, Symbol *src)
{
TPRINT("copy_sym_tree(%p, %p)\n", tpdest, src);
assert(src->scope != -1); // we accessed a variable after leaving its scope!
copy_value(&tpdest->v, tpdest->type, &src->v, src->type);
if (tpdest->type != MincVoidType && src->type != tpdest->type) {
minc_warn("Overwriting %s variable '%s' with %s", MincTypeName(tpdest->type), tpdest->name, MincTypeName(src->type));
}
tpdest->type = src->type;
TPRINT("dest: ");
print_value(&tpdest->v, tpdest->type);
}
static void
copy_tree_sym(Symbol *dest, Tree tpsrc)
{
TPRINT("copy_tree_sym(%p, %p)\n", dest, tpsrc);
assert(dest->scope != -1); // we accessed a variable after leaving its scope!
copy_value(&dest->v, dest->type, &tpsrc->v, tpsrc->type);
if (dest->type != MincVoidType && tpsrc->type != dest->type) {
minc_warn("Overwriting %s variable '%s' with %s", MincTypeName(dest->type), dest->name, MincTypeName(tpsrc->type));
}
dest->type = tpsrc->type;
}
static void
copy_tree_listelem(MincListElem *dest, Tree tpsrc)
{
TPRINT("copy_tree_listelem(%p, %p)\n", dest, tpsrc);
copy_value(&dest->val, dest->type, &tpsrc->v, tpsrc->type);
dest->type = tpsrc->type;
}
static void
copy_listelem_tree(Tree tpdest, MincListElem *esrc)
{
TPRINT("copy_listelem_tree(%p, %p)\n", tpdest, esrc);
copy_value(&tpdest->v, tpdest->type, &esrc->val, esrc->type);
tpdest->type = esrc->type;
}
static void
copy_listelem_elem(MincListElem *edest, MincListElem *esrc)
{
TPRINT("copy_listelem_elem(%p, %p)\n", edest, esrc);
copy_value(&edest->val, edest->type, &esrc->val, esrc->type);
edest->type = esrc->type;
}
/* This recursive function frees space. */
void
free_tree(Tree tp)
{
if (tp == NULL)
return;
#ifdef DEBUG_MEMORY
TPRINT("entering free_tree(%p) (%s)\n", tp, printNodeKind(tp->kind));
#endif
switch (tp->kind) {
case NodeZero:
break;
case NodeSeq:
case NodeFuncSeq:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeStore:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeList:
free_tree(tp->u.child[0]);
break;
case NodeListElem:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeEmptyListElem:
break;
case NodeSubscriptRead:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeSubscriptWrite:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
break;
case NodeOpAssign:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeName:
case NodeAutoName:
break;
case NodeDecl:
break;
case NodeFuncDecl:
break;
case NodeBlock:
free_tree(tp->u.child[0]);
break;
case NodeString:
break;
case NodeConstf:
break;
case NodeFuncDef:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
break;
case NodeArgListElem:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeArgList:
free_tree(tp->u.child[0]);
break;
case NodeRet:
free_tree(tp->u.child[0]);
break;
case NodeCall:
free_tree(tp->u.child[0]);
break;
case NodeNot:
free_tree(tp->u.child[0]);
break;
case NodeAnd:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeRelation:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeOperator:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeUnaryOperator:
free_tree(tp->u.child[0]);
break;
case NodeOr:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeIf:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeIfElse:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
break;
case NodeWhile:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeNoop:
break;
case NodeFor:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
free_tree(tp->u.child[3]);
break;
default:
minc_internal_error("free_tree: tried to destroy invalid node '%s'", printNodeKind(tp->kind));
break;
} /* switch kind */
if (tp->type == MincHandleType) {
unref_handle(tp->v.handle);
}
else if (tp->type == MincListType) {
unref_value_list(&tp->v);
}
tp->type = MincVoidType; // To prevent double-free
efree(tp); /* actually free space */
#ifdef DEBUG_MEMORY
--numTrees;
TPRINT("[%d trees left]\n", numTrees);
#endif
// TPRINT("leaving free_tree(%p)\n", tp);
}
void print_tree(Tree tp)
{
#ifdef DEBUG
rtcmix_print("Tree %p: %s type: %d\n", tp, printNodeKind(tp->kind), tp->type);
if (tp->kind == NodeName) {
rtcmix_print("Symbol:\n");
print_symbol(tp->u.symbol);
}
else if (tp->type == MincVoidType && tp->u.child[0] != NULL) {
rtcmix_print("Child 0:\n");
print_tree(tp->u.child[0]);
}
#endif
}
void print_symbol(struct symbol * s)
{
rtcmix_print("Symbol %p: '%s' scope: %d type: %d\n", s, s->name, s->scope, s->type);
}
void print_value(MincValue *v, MincDataType type)
{
switch (type) {
case MincFloatType:
TPRINT("%f\n", v->number);
break;
case MincHandleType:
TPRINT("%p\n", v->handle);
break;
case MincListType:
TPRINT("%p\n", v->list);
break;
case MincStringType:
TPRINT("%s\n", v->string);
break;
case MincVoidType:
TPRINT("void\n");
break;
}
}
void
clear_elem(MincListElem *elem)
{
if (elem->type == MincListType) {
TPRINT("clear_elem(%p)\n", elem);
unref_value_list(&elem->val);
}
else if (elem->type == MincHandleType) {
TPRINT("clear_elem(%p)\n", elem);
unref_handle(elem->val.handle);
}
}
void
unref_value_list(MincValue *value)
{
if (value->list == NULL)
return;
#ifdef DEBUG_MEMORY
TPRINT("unref_value_list(%p) [%d -> %d]\n", value->list, value->list->refcount, value->list->refcount-1);
#endif
assert(value->list->refcount > 0);
if (--value->list->refcount == 0) {
if (value->list->data != NULL) {
int e;
TPRINT("\tfreeing MincList data %p...\n", value->list->data);
for (e = 0; e < value->list->len; ++e) {
MincListElem *elem = &value->list->data[e];
clear_elem(elem);
}
efree(value->list->data);
value->list->data = NULL;
TPRINT("\tdone\n");
}
TPRINT("\tfreeing MincList %p\n", value->list);
efree(value->list);
}
}
Added ability to add (concatenate) two lists.
/* RTcmix - Copyright (C) 2004 The RTcmix Development Team
See ``AUTHORS'' for a list of contributors. See ``LICENSE'' for
the license to this software and for a DISCLAIMER OF ALL WARRANTIES.
*/
/* A revised MinC, supporting lists, types and other fun things.
Based heavily on the classic cmix version by Lars Graf.
Doug Scott added the '#' and '//' comment parsing.
John Gibson <johgibso at indiana dot edu>, 1/20/04
*/
/* This file holds the intermediate tree representation. */
#undef DEBUG
#include "minc_internal.h"
#include "handle.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>
extern "C" {
void yyset_lineno(int line_number);
int yyget_lineno(void);
};
/* We maintain a stack of MAXSTACK lists, which we access when forming
user lists (i.e., {1, 2, "foo"}) and function argument lists. Each
element of this stack is a list, allocated and freed by push_list and
pop_list. <list> is an array of MincListElem structures, each having
a type and a value, which is encoded in a MincValue union. Nested lists
and lists of mixed types are possible.
*/
static MincListElem *sMincList;
static int sMincListLen;
static MincListElem *list_stack[MAXSTACK];
static int list_len_stack[MAXSTACK];
static int list_stack_ptr;
static int sArgListLen; // number of arguments passed to a user-declared function
static int sArgListIndex; // used to walk passed-in args for user-declared functions
static bool inCalledFunctionArgList = false;
static const char *sCalledFunction;
static int sFunctionCallDepth = 0; // level of actively-executing function calls
static bool inFunctionCall() { return sFunctionCallDepth > 0; }
#undef DEBUG_TRACE
#if defined(DEBUG_TRACE)
class Trace {
public:
Trace(const char *func) : mFunc(func) {
rtcmix_print("%s%s -->\n", spaces, mFunc);
++sTraceDepth;
for (int n =0; n<sTraceDepth*3; ++n) { spaces[n] = ' '; }
spaces[sTraceDepth*3] = '\0';
}
static char *getBuf() { return sMsgbuf; }
static void printBuf() { rtcmix_print("%s%s", spaces, sMsgbuf); }
~Trace() {
--sTraceDepth;
for (int n =0; n<sTraceDepth*3; ++n) { spaces[n] = ' '; }
spaces[sTraceDepth*3] = '\0';
rtcmix_print("%s<-- %s\n", spaces, mFunc);
}
private:
static char sMsgbuf[];
const char *mFunc;
static int sTraceDepth;
static char spaces[];
};
char Trace::sMsgbuf[256];
int Trace::sTraceDepth = 0;
char Trace::spaces[128];
#define ENTER() Trace __trace__(__FUNCTION__)
#define TPRINT(...) do { snprintf(Trace::getBuf(), 256, __VA_ARGS__); Trace::printBuf(); } while(0)
#else
#define ENTER()
#define TPRINT(...)
#endif
#undef DEBUG_MEMORY
#ifdef DEBUG_MEMORY
static int numTrees = 0;
#endif
static const char *s_NodeKinds[] = {
"NodeZero",
"NodeSeq",
"NodeStore",
"NodeList",
"NodeListElem",
"NodeEmptyListElem",
"NodeSubscriptRead",
"NodeSubscriptWrite",
"NodeOpAssign",
"NodeName",
"NodeAutoName",
"NodeConstf",
"NodeString",
"NodeFuncDef",
"NodeArgList",
"NodeArgListElem",
"NodeRet",
"NodeFuncSeq",
"NodeCall",
"NodeAnd",
"NodeOr",
"NodeOperator",
"NodeUnaryOperator",
"NodeNot",
"NodeRelation",
"NodeIf",
"NodeWhile",
"NodeFor",
"NodeIfElse",
"NodeDecl",
"NodeFuncDecl",
"NodeBlock",
"NodeNoop"
};
static const char *s_OpKinds[] = {
"ILLEGAL",
"ILLEGAL",
"+",
"-",
"*",
"/",
"%",
"^",
"-",
"==",
"!=",
"<",
">",
"<=",
">="
};
static const char *printNodeKind(NodeKind k)
{
return s_NodeKinds[k];
}
static const char *printOpKind(OpKind k)
{
return s_OpKinds[k];
}
/* prototypes for local functions */
static int cmp(MincFloat f1, MincFloat f2);
static Tree node(OpKind op, NodeKind kind);
static void push_list(void);
static void pop_list(void);
static void copy_tree_tree(Tree tpdest, Tree tpsrc);
static void copy_sym_tree(Tree tpdest, Symbol *src);
static void copy_tree_sym(Symbol *dest, Tree tpsrc);
static void copy_tree_listelem(MincListElem *edest, Tree tpsrc);
static void copy_listelem_tree(Tree tpdest, MincListElem *esrc);
static void copy_listelem_elem(MincListElem *edest, MincListElem *esrc);
/* floating point comparisons:
f1 < f2 ==> -1
f1 == f2 ==> 0
f1 > f2 ==> 1
*/
static int
cmp(MincFloat f1, MincFloat f2)
{
if (fabs((double) f1 - (double) f2) < EPSILON) {
/* printf("cmp=%g %g %g \n",f1,f2,fabs(f1-f2)); */
return 0;
}
if ((f1 - f2) > EPSILON) {
/* printf("cmp > %g %g %g \n",f1,f2,fabs(f1-f2)); */
return 1;
}
if ((f2 - f1) > EPSILON) {
/* printf("cmp <%g %g %g \n",f1,f2,fabs(f1-f2)); */
return -1;
}
return 0;
}
static MincList *
newList(int len)
{
ENTER();
MincList *list = (MincList *) emalloc(sizeof(MincList));
if (list) {
list->len = len;
list->refcount = 0;
if (len > 0) {
list->data = (MincListElem *) emalloc(len * sizeof(MincListElem));
if (!list->data) {
efree(list);
list = NULL;
}
else {
memset(list->data, 0, len * sizeof(MincListElem));
}
}
else
list->data = NULL;
TPRINT("newList: %p alloc'd at len %d\n", list, sMincListLen);
}
return list;
}
static void
resizeList(MincList *list, int newLen)
{
int i;
list->data = (MincListElem *) realloc(list->data, sizeof(MincListElem) * newLen);
for (i = list->len; i < newLen; i++) {
list->data[i].type = MincFloatType;
list->data[i].val.number = 0.0;
}
list->len = newLen;
}
/* ========================================================================== */
/* Tree nodes */
static Tree
node(OpKind op, NodeKind kind)
{
Tree tp;
tp = (Tree) emalloc(sizeof(struct tree));
if (tp == NULL)
return NULL;
tp->op = op;
tp->kind = kind;
tp->type = MincVoidType;
tp->u.child[0] = NULL; /* these clear entire <u> union */
tp->u.child[1] = NULL;
tp->u.child[2] = NULL;
tp->u.child[3] = NULL;
tp->v.list = NULL;
tp->name = NULL;
tp->lineno = yyget_lineno();
#ifdef DEBUG_MEMORY
++numTrees;
TPRINT("[%d trees in existence]\n", numTrees);
#endif
return tp;
}
Tree
tnoop()
{
Tree tp = node(OpFree, NodeNoop);
TPRINT("tnoop => NodeNoop %p\n", tp);
return tp;
}
Tree
tseq(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeSeq);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tseq (%p, %p) => NodeSeq %p\n", e1, e2, tp);
return tp;
}
Tree
top(OpKind op, Tree e1, Tree e2)
{
Tree tp = node(op, NodeOperator);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("top (%d, %p, %p) => NodeOperator %p\n", op, e1, e2, tp);
return tp;
}
Tree
tunop(OpKind op, Tree e1)
{
Tree tp = node(op, NodeUnaryOperator);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
TPRINT("tunop (%d, %p) => NodeUnaryOperator %p\n", op, e1, tp);
return tp;
}
/* store a value into a variable */
Tree
tstore(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeStore);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tstore (%p, %p) => NodeStore %p\n", e1, e2, tp);
return tp;
}
/* like tstore, but modify value before storing into variable */
Tree
topassign(Tree e1, Tree e2, OpKind op)
{
Tree tp = node(op, NodeOpAssign);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("topassign, op=%d (%p, %p) => NodeOpAssign %p\n", op, e1, e2, tp);
return tp;
}
/* looks up symbol name and get the symbol.
converts symbol table entry into tree
or initialize tree node to a symbol entry
*/
Tree
tname(const char *symbolName)
{
Tree tp = node(OpFree, NodeName);
if (tp == NULL)
return NULL;
tp->name = symbolName;
TPRINT("tname ('%s') => NodeName %p\n", symbolName, tp);
return tp;
}
/* looks up symbol name and get the symbol, and auto-declares it if not found
converts symbol table entry into tree
or initialize tree node to a symbol entry
*/
Tree
tautoname(const char *symbolName)
{
Tree tp = node(OpFree, NodeAutoName);
if (tp == NULL)
return NULL;
tp->name = symbolName;
TPRINT("tautoname ('%s') => NodeAutoName %p\n", symbolName, tp);
return tp;
}
Tree
tstring(const char *str)
{
Tree tp = node(OpFree, NodeString);
if (tp == NULL)
return NULL;
tp->u.string = str;
TPRINT("tstring ('%s') => NodeString %p\n", str, tp);
return tp;
}
Tree
tconstf(MincFloat num)
{
Tree tp = node(OpFree, NodeConstf);
if (tp == NULL)
return NULL;
tp->u.number = num;
TPRINT("tconstf (%f) => NodeConstf %p\n", num, tp);
return tp;
}
Tree
targlistelem(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeArgListElem);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // previous NodeArgListElem
tp->u.child[1] = e2; // payload (NodeDecl for arg)
TPRINT("targlistelem (%p, %p) => NodeArgListElem %p\n", e1, e2, tp);
return tp;
}
Tree
targlist(Tree e1)
{
Tree tp = node(OpFree, NodeArgList);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // tail of NodeArgListElem linked list
TPRINT("targlist (%p) => NodeArgList %p\n", e1, tp);
return tp;
}
Tree
treturn(Tree e1)
{
Tree tp = node(OpFree, NodeRet);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // Node containing RHS for return
TPRINT("treturn (%p) => NodeRet %p\n", e1, tp);
return tp;
}
Tree tfuncseq(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeFuncSeq);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tfuncseq (%p, %p) => NodeFuncSeq %p\n", e1, e2, tp);
return tp;
}
Tree
tfdef(Tree e1, Tree e2, Tree e3)
{
Tree tp = node(OpFree, NodeFuncDef);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // Lookup node
tp->u.child[1] = e2; // NodeArgList (argument symbol decls)
tp->u.child[2] = e3; // NodeFuncSeq function body (statements), which returns value
// Right now, this last is handed to the Symbol and
// then NULL'd here in exct()
TPRINT("tfdef (%p, %p, %p) => NodeFuncDef %p\n", e1, e2, e3, tp);
return tp;
}
Tree
tcall(Tree args, const char *funcname)
{
Tree tp = node(OpFree, NodeCall);
if (tp == NULL)
return NULL;
tp->name = funcname;
tp->u.child[0] = args;
TPRINT("tcall (%p, '%s') => NodeCall %p\n", args, funcname, tp);
return tp;
}
Tree
tcand(Tree test1, Tree test2)
{
Tree tp = node(OpFree, NodeAnd);
if (tp == NULL)
return NULL;
tp->u.child[0] = test1;
tp->u.child[1] = test2;
TPRINT("tcand (%p, %p) => NodeAnd %p\n", test1, test2, tp);
return tp;
}
Tree
tcor(Tree test1, Tree test2)
{
Tree tp = node(OpFree, NodeOr);
if (tp == NULL)
return NULL;
tp->u.child[0] = test1;
tp->u.child[1] = test2;
TPRINT("tcor (%p, %p) => NodeOr %p\n", test1, test2, tp);
return tp;
}
Tree
tnot(Tree test1)
{
Tree tp = node(OpFree, NodeNot);
if (tp == NULL)
return NULL;
tp->u.child[0] = test1;
TPRINT("tnot (%p) => NodeNot %p\n", test1, tp);
return tp;
}
Tree
trel(OpKind op, Tree e1, Tree e2)
{
Tree tp = node(op, NodeRelation);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("trel (%d, %p, %p) => NodeRelation %p\n", op, e1, e2, tp);
return tp;
}
/* Create list: either an argument list or a user array. Why do we
not separate these two things? Because at the time when we need
to push the list elements onto a stack, we don't know whether they
form part of a user list or an argument list.
*/
Tree
tlist(Tree e1)
{
Tree tp = node(OpFree, NodeList);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // tail of NodeListElem linked list
TPRINT("tlist (%p) => NodeList %p\n", e1, tp);
return tp;
}
Tree
tlistelem(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeListElem);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1; // previous elem
tp->u.child[1] = e2; // payload (contents of exp)
TPRINT("tlistelem (%p, %p) => NodeListElem %p\n", e1, e2, tp);
return tp;
}
Tree
temptylistelem()
{
Tree tp = node(OpFree, NodeEmptyListElem);
TPRINT("temptylistelem => NodeEmptyListElem %p\n", tp);
return tp;
}
Tree
tsubscriptread(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeSubscriptRead);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tsubscriptread (%p, %p) => NodeSubscriptRead %p\n", e1, e2, tp);
return tp;
}
Tree
tsubscriptwrite(Tree e1, Tree e2, Tree e3)
{
Tree tp = node(OpFree, NodeSubscriptWrite);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
tp->u.child[2] = e3;
TPRINT("tsubscriptwrite (%p, %p, %p) => NodeSubscriptWrite %p\n", e1, e2, e3, tp);
return tp;
}
Tree
tif(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeIf);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("tif (%p, %p) => NodeIf %p\n", e1, e2, tp);
return tp;
}
Tree
tifelse(Tree e1, Tree e2, Tree e3)
{
Tree tp = node(OpFree, NodeIfElse);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
tp->u.child[2] = e3;
TPRINT("tifelse (%p, %p, %p) => NodeIfElse %p\n", e1, e2, e3, tp);
return tp;
}
Tree
tfor(Tree e1, Tree e2, Tree e3, Tree e4)
{
Tree tp = node(OpFree, NodeFor);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
tp->u.child[2] = e3;
tp->u.child[3] = e4;
TPRINT("tfor (%p, %p, %p, <e4>) => NodeFor %p\n", e1, e2, e3, tp);
return tp;
}
Tree
twhile(Tree e1, Tree e2)
{
Tree tp = node(OpFree, NodeWhile);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
tp->u.child[1] = e2;
TPRINT("twhile (%p, %p) => NodeWhile %p\n", e1, e2, tp);
return tp;
}
Tree tdecl(const char *name, MincDataType type)
{
Tree tp = node(OpFree, NodeDecl);
if (tp == NULL)
return NULL;
tp->name = name;
tp->type = type;
TPRINT("tdecl ('%s') => NodeDecl %p\n", name, tp);
return tp;
}
Tree tfdecl(const char *name, MincDataType type)
{
Tree tp = node(OpFree, NodeFuncDecl);
if (tp == NULL)
return NULL;
tp->name = name;
tp->type = type;
TPRINT("tfdecl ('%s') => NodeFuncDecl %p\n", name, tp);
return tp;
}
Tree tblock(Tree e1)
{
Tree tp = node(OpFree, NodeBlock);
if (tp == NULL)
return NULL;
tp->u.child[0] = e1;
TPRINT("tblock (%p) => NodeBlock %p\n", e1, tp);
return tp;
}
/* ========================================================================== */
/* Operators */
/* ---------------------------------------------------------- do_op_string -- */
static void
do_op_string(Tree tp, const char *str1, const char *str2, OpKind op)
{
ENTER();
char *s;
unsigned long len;
switch (op) {
case OpPlus: /* concatenate */
len = (strlen(str1) + strlen(str2)) + 1;
s = (char *) emalloc(sizeof(char) * len);
if (s == NULL)
return;
strcpy(s, str1);
strcat(s, str2);
tp->v.string = s;
// printf("str1=%s, str2=%s len=%d, s=%s\n", str1, str2, len, s);
break;
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
case OpNeg:
minc_warn("unsupported operation on a string");
return;
default:
minc_internal_error("invalid string operator");
break;
}
tp->type = MincStringType;
}
/* ------------------------------------------------------------- do_op_num -- */
static void
do_op_num(Tree tp, const MincFloat val1, const MincFloat val2, OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
tp->v.number = val1 + val2;
break;
case OpMinus:
tp->v.number = val1 - val2;
break;
case OpMul:
tp->v.number = val1 * val2;
break;
case OpDiv:
tp->v.number = val1 / val2;
break;
case OpMod:
tp->v.number = (MincFloat) ((long) val1 % (long) val2);
break;
case OpPow:
tp->v.number = pow(val1, val2);
break;
case OpNeg:
tp->v.number = -val1; /* <val2> ignored */
break;
default:
minc_internal_error("invalid numeric operator");
break;
}
tp->type = MincFloatType;
}
/* ------------------------------------------------------ do_op_handle_num -- */
static void
do_op_handle_num(Tree tp, const MincHandle val1, const MincFloat val2,
OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
tp->v.handle = minc_binop_handle_float(val1, val2, op);
ref_handle(tp->v.handle);
break;
case OpNeg:
tp->v.handle = minc_binop_handle_float(val1, -1.0, OpMul); // <val2> ignored
ref_handle(tp->v.handle);
break;
default:
minc_internal_error("invalid operator for handle and number");
break;
}
tp->type = MincHandleType;
}
/* ------------------------------------------------------ do_op_num_handle -- */
static void
do_op_num_handle(Tree tp, const MincFloat val1, const MincHandle val2,
OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
tp->v.handle = minc_binop_float_handle(val1, val2, op);
ref_handle(tp->v.handle);
break;
case OpNeg:
/* fall through */
default:
minc_internal_error("invalid operator for handle and number");
break;
}
tp->type = MincHandleType;
}
/* --------------------------------------------------- do_op_handle_handle -- */
static void
do_op_handle_handle(Tree tp, const MincHandle val1, const MincHandle val2,
OpKind op)
{
ENTER();
switch (op) {
case OpPlus:
case OpMinus:
case OpMul:
case OpDiv:
case OpMod:
case OpPow:
tp->v.handle = minc_binop_handles(val1, val2, op);
ref_handle(tp->v.handle);
break;
case OpNeg:
default:
minc_internal_error("invalid binary handle operator");
break;
}
if (tp->v.handle)
tp->type = MincHandleType;
}
/* ---------------------------------------------------- do_op_list_iterate -- */
/* Iterate over <child>'s list, performing the operation specified by <op>,
using the scalar <val>, for each list element. Store the result into a
new list for <tp>, so that child's list is unchanged.
*/
static void
do_op_list_iterate(Tree tp, Tree child, const MincFloat val, const OpKind op)
{
ENTER();
int i;
MincListElem *dest;
const MincList *srcList = child->v.list;
const int len = srcList->len;
MincListElem *src = srcList->data;
MincList *destList = newList(len);
if (destList == NULL)
return;
dest = destList->data;
assert(len >= 0);
switch (op) {
case OpPlus:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number + val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpMinus:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number - val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpMul:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number * val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpDiv:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = src[i].val.number / val;
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpMod:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = (MincFloat) ((long) src[i].val.number
% (long) val);
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpPow:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = (MincFloat) pow((double) src[i].val.number,
(double) val);
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
case OpNeg:
for (i = 0; i < len; i++) {
if (src[i].type == MincFloatType)
dest[i].val.number = -src[i].val.number; /* <val> ignored */
else
dest[i].val = src[i].val;
dest[i].type = src[i].type;
}
break;
default:
for (i = 0; i < len; i++)
dest[i].val.number = 0.0;
minc_internal_error("invalid list operator");
break;
}
assert(tp->type == MincVoidType); // are we ever overwriting these?
tp->type = MincListType;
assert(tp->v.list == NULL);
tp->v.list = destList;
TPRINT("do_op_list_iterate: list %p refcount %d -> %d\n", destList, destList->refcount, destList->refcount+1);
++destList->refcount;
}
/* ---------------------------------------------------- do_op_list_list -- */
/* Currently just supports + and +=, concatenating the lists. Store the result into a
new list for <tp>, so that child's list is unchanged. N.B. This will operate on zero-length
and NULL lists as well.
*/
static void
do_op_list_list(Tree tp, Tree child1, Tree child2, const OpKind op)
{
ENTER();
int i, n;
const MincList *list1 = child1->v.list;
const int len1 = (list1) ? list1->len : 0;
MincListElem *src1 = (list1) ? list1->data : NULL;
const MincList *list2 = child2->v.list;
const int len2 = (list2) ? list2->len : 0;
MincListElem *src2 = (list2) ? list2->data : NULL;
MincList *destList;
MincListElem *dest;
switch (op) {
case OpPlus:
destList = newList(len1+len2);
if (destList == NULL)
return;
dest = destList->data;
for (i = 0, n = 0; i < len1; ++i, ++n) {
dest[i] = src1[n];
}
for (n = 0; n < len2; ++i, ++n) {
dest[i] = src2[n];
}
break;
default:
minc_warn("invalid operator for two lists");
destList = newList(0); // return zero-length list
break;
}
if (tp->type == MincListType) { // if we are overwriting
unref_value_list(&tp->v);
}
tp->type = MincListType;
tp->v.list = destList;
TPRINT("do_op_list_list: list %p refcount %d -> %d\n", destList, destList->refcount, destList->refcount+1);
++destList->refcount;
}
/* --------------------------------------------------------- exct_operator -- */
static void
exct_operator(Tree tp, OpKind op)
{
ENTER();
Tree child0, child1;
child0 = exct(tp->u.child[0]);
child1 = exct(tp->u.child[1]);
switch (child0->type) {
case MincFloatType:
switch (child1->type) {
case MincFloatType:
do_op_num(tp, child0->v.number, child1->v.number, op);
break;
case MincStringType:
{
char buf[64];
snprintf(buf, 64, "%g", child0->v.number);
do_op_string(tp, buf, child1->v.string, op);
}
break;
case MincHandleType:
do_op_num_handle(tp, child0->v.number, child1->v.handle, op);
break;
case MincListType:
/* Check for nonsensical ops. */
if (op == OpMinus)
minc_warn("can't subtract a list from a number");
else if (op == OpDiv)
minc_warn("can't divide a number by a list");
else
do_op_list_iterate(tp, child1, child0->v.number, op);
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
case MincStringType:
switch (child1->type) {
case MincFloatType:
{
char buf[64];
snprintf(buf, 64, "%g", child1->v.number);
do_op_string(tp, child0->v.string, buf, op);
}
break;
case MincStringType:
do_op_string(tp, child0->v.string, child1->v.string, op);
break;
case MincHandleType:
minc_warn("can't operate on a string and a handle");
break;
case MincListType:
minc_warn("can't operate on a string and a list");
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
case MincHandleType:
switch (child1->type) {
case MincFloatType:
do_op_handle_num(tp, child0->v.handle, child1->v.number, op);
break;
case MincStringType:
minc_warn("can't operate on a string and a handle");
break;
case MincHandleType:
do_op_handle_handle(tp, child0->v.handle, child1->v.handle, op);
break;
case MincListType:
minc_warn("can't operate on a list and a handle");
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
case MincListType:
switch (child1->type) {
case MincFloatType:
do_op_list_iterate(tp, child0, child1->v.number, op);
break;
case MincStringType:
minc_warn("can't operate on a string");
break;
case MincHandleType:
minc_warn("can't operate on a handle");
break;
case MincListType:
do_op_list_list(tp, child0, child1, op);
break;
default:
minc_internal_error("operator %s: invalid rhs type: %s", printOpKind(op), MincTypeName(child1->type));
break;
}
break;
default:
minc_internal_error("operator %s: invalid lhs type: %s", printOpKind(op), MincTypeName(child0->type));
break;
}
}
/* --------------------------------------------------------- exct_relation -- */
static void
exct_relation(Tree tp)
{
ENTER();
Tree tp0 = exct(tp->u.child[0]);
Tree tp1 = exct(tp->u.child[1]);
tp->type = MincFloatType;
if (tp0->type != tp1->type) {
minc_warn("operator %s: attempt to compare variables having different types", printOpKind(tp->op));
tp->v.number = 0.0;
return;
}
switch (tp->op) {
case OpEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
case MincStringType:
if (strcmp(tp0->v.string, tp1->v.string) == 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpNotEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == 0)
tp->v.number = 0.0;
else
tp->v.number = 1.0;
break;
case MincStringType:
if (strcmp(tp0->v.string, tp1->v.string) == 0)
tp->v.number = 0.0;
else
tp->v.number = 1.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpLess:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == -1)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpGreater:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) == 1)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpLessEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) <= 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
case OpGreaterEqual:
switch (tp0->type) {
case MincFloatType:
if (cmp(tp0->v.number, tp1->v.number) >= 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
default:
goto unsupported_type;
break;
}
break;
default:
minc_internal_error("exct: tried to execute invalid NodeRelation");
break;
}
return;
unsupported_type:
minc_internal_error("operator %s: can't compare this type of object", printOpKind(tp->op));
}
/* --------------------------------------------------------- exct_opassign -- */
static void
exct_opassign(Tree tp, OpKind op)
{
ENTER();
Tree tp0 = exct(tp->u.child[0]);
Tree tp1 = exct(tp->u.child[1]);
if (tp0->u.symbol->type != MincFloatType || tp1->type != MincFloatType) {
minc_warn("can only use '%c=' with numbers",
op == OpPlus ? '+' : (op == OpMinus ? '-'
: (op == OpMul ? '*' : '/')));
//FIXME: Is this correct?
// memcpy(&tp->v, &tp0->u.symbol->v, sizeof(MincValue));
// tp->type = tp0->type;
copy_sym_tree(tp, tp0->u.symbol);
return;
}
switch (tp->op) {
case OpPlus:
tp0->u.symbol->v.number += tp1->v.number;
break;
case OpMinus:
tp0->u.symbol->v.number -= tp1->v.number;
break;
case OpMul:
tp0->u.symbol->v.number *= tp1->v.number;
break;
case OpDiv:
tp0->u.symbol->v.number /= tp1->v.number;
break;
default:
minc_internal_error("exct: tried to execute invalid NodeOpAssign");
break;
}
tp0->u.symbol->type = tp1->type;
tp->v.number = tp0->u.symbol->v.number;
tp->type = tp1->type;
}
/* --------------------------------------------------- exct_subscript_read -- */
static void
exct_subscript_read(Tree tp)
{
ENTER();
exct(tp->u.child[0]); /* lookup target */
exct(tp->u.child[1]);
if (tp->u.child[1]->type == MincFloatType) {
if (tp->u.child[0]->u.symbol->type == MincListType) {
MincListElem elem;
MincFloat fltindex = tp->u.child[1]->v.number;
int index = (int) fltindex;
MincFloat frac = fltindex - index;
MincList *theList = tp->u.child[0]->u.symbol->v.list;
if (theList == NULL) {
minc_die("attempt to index a NULL list");
return;
}
int len = theList->len;
if (len == 0) {
minc_die("attempt to index an empty list");
return;
}
if (fltindex < 0.0) { /* -1 means last element */
if (fltindex <= -2.0)
minc_warn("negative index ... returning last element");
index = len - 1;
fltindex = (MincFloat) index;
}
else if (fltindex > (MincFloat) (len - 1)) {
minc_warn("attempt to index past the end of list ... "
"returning last element");
index = len - 1;
fltindex = (MincFloat) index;
}
elem.type = MincVoidType;
copy_listelem_elem(&elem, &theList->data[index]);
/* do linear interpolation for float items */
if (elem.type == MincFloatType && frac > 0.0 && index < len - 1) {
MincListElem elem2 = theList->data[index + 1];
if (elem2.type == MincFloatType)
tp->v.number = elem.val.number
+ (frac * (elem2.val.number - elem.val.number));
else /* can't interpolate btw. a number and another type */
tp->v.number = elem.val.number;
tp->type = elem.type;
}
else {
copy_listelem_tree(tp, &elem);
}
clear_elem(&elem);
}
else
minc_die("attempt to index a variable that's not a list");
}
else
minc_die("list index must be a number");
}
/* -------------------------------------------------- exct_subscript_write -- */
static void
exct_subscript_write(Tree tp)
{
ENTER();
exct(tp->u.child[0]); /* lookup target */
exct(tp->u.child[1]); /* index */
exct(tp->u.child[2]); /* expression to store */
if (tp->u.child[1]->type == MincFloatType) {
if (tp->u.child[0]->u.symbol->type == MincListType) {
int len = 0;
MincList *theList = tp->u.child[0]->u.symbol->v.list;
MincFloat fltindex = tp->u.child[1]->v.number;
int index = (int) fltindex;
if (fltindex - (MincFloat) index > 0.0)
minc_warn("list index must be integer ... correcting");
if (theList != NULL) {
len = theList->len;
assert(len >= 0); /* NB: okay to have zero-length list */
}
if (index == -1) /* means last element */
index = len > 0 ? len - 1 : 0;
else if (index >= len) {
/* resize list */
int i, newslots, oldlen = len;
newslots = len > 0 ? (index - (len - 1)) : index + 1;
len += newslots;
if (len < 0) {
minc_die("list array subscript exceeds integer size limit!");
}
if (theList == NULL)
tp->u.child[0]->u.symbol->v.list = theList = newList(len);
else
resizeList(theList, len);
TPRINT("exct_subscript_write: MincList %p expanded to len %d\n",
theList->data, len);
// Ref the list if just allocated.
if (theList->refcount == 0)
theList->refcount = 1;
TPRINT("list %p refcount = 1\n", theList);
}
copy_tree_listelem(&theList->data[index], tp->u.child[2]);
assert(theList->data[index].type == tp->u.child[2]->type);
copy_tree_tree(tp, tp->u.child[2]);
}
else
minc_die("attempt to index a variable that's not a list");
}
else
minc_die("list index must be a number");
}
/* ========================================================================== */
/* Tree execution and disposal */
/* ------------------------------------------------------ check_list_count -- */
/* This protects us against a situation that can arise due to our use of
'{' and '}' to delimit both statements and list contents. If you write
the following in a script, it will quickly chew through all available
memory, as it allocates a zero-length block for an empty list on each
iteration.
while (1) {}
This function prevents this from going on for too many thousands of
iterations.
*/
#define MAX_LISTS 50000
static int
check_list_count()
{
static int list_count = 0;
if (++list_count > MAX_LISTS) {
minc_die("Bailing out due to suspected infinite loop on "
"empty code block\n(e.g., \"while (1) {}\").");
return -1;
}
return 0;
}
/* ------------------------------------------------------------------ exct -- */
/* This recursive function interprets the intermediate code.
*/
Tree
exct(Tree tp)
{
if (tp == NULL || was_rtcmix_error())
return NULL;
ENTER();
TPRINT("%s: tp=%p\n", printNodeKind(tp->kind), tp);
if (inFunctionCall() && tp->lineno > 0) {
yyset_lineno(tp->lineno);
}
switch (tp->kind) {
case NodeConstf:
tp->type = MincFloatType;
tp->v.number = tp->u.number;
break;
case NodeString:
tp->type = MincStringType;
tp->v.string = tp->u.string;
break;
case NodeName:
case NodeAutoName:
/* look up the symbol */
if (tp->kind == NodeName) {
tp->u.symbol = lookup(tp->name, AnyLevel);
}
else if (tp->kind == NodeAutoName) {
tp->u.symbol = lookupOrAutodeclare(tp->name, sFunctionCallDepth > 0 ? YES : NO);
}
else {
minc_internal_error("NodeName/NodeAutoName exct: illegal node kind: %d", tp->kind);
}
if (tp->u.symbol) {
TPRINT("NodeName/NodeAutoName: symbol %p\n", tp->u.symbol);
/* also assign the symbol's value into tree's value field */
TPRINT("NodeName/NodeAutoName: copying value from symbol '%s' to us\n", tp->u.symbol->name);
copy_sym_tree(tp, tp->u.symbol);
tp->name = tp->u.symbol->name; // for debugging -- not used
assert(tp->type == tp->u.symbol->type);
}
else {
// FIXME: install id w/ value of 0, then warn??
minc_die("'%s' is not declared", tp->name);
}
break;
case NodeListElem:
TPRINT("NodeListElem exct'ing Tree link %p\n", tp->u.child[0]);
exct(tp->u.child[0]);
if (sMincListLen == MAXDISPARGS) {
minc_die("exceeded maximum number of items for a list");
}
else {
TPRINT("NodeListElem %p evaluating payload child Tree %p\n", tp, tp->u.child[1]);
Tree tmp = exct(tp->u.child[1]);
/* Copy entire MincValue union from expr to tp and to stack. */
TPRINT("NodeListElem %p copying child value into self and stack\n", tp);
copy_tree_tree(tp, tmp);
copy_tree_listelem(&sMincList[sMincListLen], tmp);
assert(sMincList[sMincListLen].type == tmp->type);
sMincListLen++;
TPRINT("NodeListElem: list at level %d now len %d\n", list_stack_ptr, sMincListLen);
}
break;
case NodeEmptyListElem:
/* do nothing */
break;
case NodeList:
push_list();
exct(tp->u.child[0]); /* NB: increments sMincListLen */
{
MincList *theList;
int i;
if (check_list_count() < 0)
return tp;
theList = newList(sMincListLen);
if (theList == NULL)
return NULL;
if (tp->type == MincListType && tp->v.list != NULL)
unref_value_list(&tp->v);
tp->type = MincListType;
tp->v.list = theList;
TPRINT("MincList %p assigned to self\n", theList);
theList->refcount = 1;
TPRINT("MincList refcount = 1\n");
// Copy from stack list into tree list.
for (i = 0; i < sMincListLen; ++i)
copy_listelem_elem(&theList->data[i], &sMincList[i]);
}
pop_list();
break;
case NodeSubscriptRead:
exct_subscript_read(tp);
break;
case NodeSubscriptWrite:
exct_subscript_write(tp);
break;
case NodeCall:
push_list();
{
Symbol *funcSymbol = lookup(tp->name, GlobalLevel);
if (funcSymbol) {
sCalledFunction = tp->name;
/* The function's definition node was stored on the symbol at declaration time.
However, if a function was called on a non-function symbol, the tree will be NULL.
*/
Tree funcDef = funcSymbol->tree;
if (funcDef) {
TPRINT("NodeCall: func def = %p\n", funcDef);
TPRINT("NodeCall: exp decl list = %p\n", tp->u.child[0]);
exct(tp->u.child[0]); // execute arg expression list
push_function_stack();
push_scope();
int savedLineNo, savedScope, savedCallDepth;
Tree temp = NULL;
try {
/* The exp list is copied to the symbols for the function's arg list. */
exct(funcDef->u.child[1]);
savedLineNo = yyget_lineno();
savedScope = current_scope();
++sFunctionCallDepth;
savedCallDepth = sFunctionCallDepth;
TPRINT("NodeCall(%p): executing %s() block node %p, call depth now %d\n",
tp, sCalledFunction, funcDef->u.child[2], savedCallDepth);
temp = exct(funcDef->u.child[2]);
}
catch (Tree returned) { // This catches return statements!
TPRINT("NodeCall(%p) caught %p return stmt throw - restoring call depth %d\n",
tp, returned, savedCallDepth);
temp = returned;
sFunctionCallDepth = savedCallDepth;
restore_scope(savedScope);
}
catch(...) { // Anything else is an error
pop_function_stack();
--sFunctionCallDepth;
throw;
}
--sFunctionCallDepth;
TPRINT("NodeCall: function call depth => %d\n", sFunctionCallDepth);
// restore parser line number
yyset_lineno(savedLineNo);
TPRINT("NodeCall copying def exct results into self\n");
copy_tree_tree(tp, temp);
pop_function_stack();
}
else {
minc_die("'%s' is not a function", funcSymbol->name);
}
sCalledFunction = NULL;
}
else {
exct(tp->u.child[0]);
MincListElem retval;
int result = call_builtin_function(tp->name, sMincList, sMincListLen,
&retval);
if (result < 0) {
result = call_external_function(tp->name, sMincList, sMincListLen,
&retval);
}
copy_listelem_tree(tp, &retval);
assert(tp->type == retval.type);
clear_elem(&retval);
if (result != 0) {
set_rtcmix_error(result); // store fatal error from RTcmix layer (EMBEDDED ONLY)
}
}
}
pop_list();
break;
case NodeStore:
#ifdef ORIGINAL_CODE
/* N.B. Now that symbol lookup is part of tree, this happens in
the NodeName stored as child[0] */
TPRINT("NodeStore(%p): evaluate LHS %p (child 0)\n", tp, tp->u.child[0]);
exct(tp->u.child[0]);
/* evaluate RHS expression */
TPRINT("NodeStore(%p): evaluate RHS (child 1)\n", tp);
exct(tp->u.child[1]);
#else
/* evaluate RHS expression */
TPRINT("NodeStore(%p): evaluate RHS (child 1) FIRST\n", tp);
exct(tp->u.child[1]);
/* N.B. Now that symbol lookup is part of tree, this happens in
the NodeName stored as child[0] */
TPRINT("NodeStore(%p): evaluate LHS %p (child 0)\n", tp, tp->u.child[0]);
exct(tp->u.child[0]);
#endif
TPRINT("NodeStore(%p): copying value from RHS (%p) to LHS's symbol (%p)\n",
tp, tp->u.child[1], tp->u.child[0]->u.symbol);
/* Copy entire MincValue union from expr to id sym and to tp. */
copy_tree_sym(tp->u.child[0]->u.symbol, tp->u.child[1]);
assert(tp->u.child[0]->u.symbol->type == tp->u.child[1]->type);
TPRINT("NodeStore: copying value from RHS (%p) to here (%p)\n", tp->u.child[1], tp);
copy_tree_tree(tp, tp->u.child[1]);
assert(tp->type == tp->u.child[1]->type);
break;
case NodeOpAssign:
exct_opassign(tp, tp->op);
break;
case NodeNot:
tp->type = MincFloatType;
if (cmp(0.0, exct(tp->u.child[0])->v.number) == 0)
tp->v.number = 1.0;
else
tp->v.number = 0.0;
break;
case NodeAnd:
tp->type = MincFloatType;
tp->v.number = 0.0;
if (cmp(0.0, exct(tp->u.child[0])->v.number) != 0) {
if (cmp(0.0, exct(tp->u.child[1])->v.number) != 0) {
tp->type = MincFloatType;
tp->v.number = 1.0;
}
}
break;
case NodeRelation:
exct_relation(tp);
break; /* switch NodeRelation */
case NodeOperator:
exct_operator(tp, tp->op);
break; /* switch NodeOperator */
case NodeUnaryOperator:
tp->type = MincFloatType;
if (tp->op == OpNeg)
tp->v.number = -exct(tp->u.child[0])->v.number;
break;
case NodeOr:
tp->type = MincFloatType;
tp->v.number = 0.0;
if ((cmp(0.0, exct(tp->u.child[0])->v.number) != 0) ||
(cmp(0.0, exct(tp->u.child[1])->v.number) != 0)) {
tp->v.number = 1.0;
}
break;
case NodeIf:
if (cmp(0.0, exct(tp->u.child[0])->v.number) != 0)
exct(tp->u.child[1]);
break;
case NodeIfElse:
if (cmp(0.0, exct(tp->u.child[0])->v.number) != 0)
exct(tp->u.child[1]);
else
exct(tp->u.child[2]);
break;
case NodeWhile:
while (cmp(0.0, exct(tp->u.child[0])->v.number) != 0)
exct(tp->u.child[1]);
break;
case NodeArgList:
sArgListLen = 0;
sArgListIndex = 0; // reset to walk list
inCalledFunctionArgList = true;
TPRINT("NodeArgList: walking function '%s()' arg decl/copy list\n", sCalledFunction);
exct(tp->u.child[0]);
inCalledFunctionArgList = false;
break;
case NodeArgListElem:
++sArgListLen;
exct(tp->u.child[0]); // work our way to the front of the list
exct(tp->u.child[1]); // run the arg decl
{
// Symbol associated with this function argument
Symbol *argSym = tp->u.child[1]->u.symbol;
if (sMincListLen > sArgListLen) {
minc_die("%s() takes %d arguments but was passed %d!", sCalledFunction, sArgListLen, sMincListLen);
}
else if (sArgListIndex >= sMincListLen) {
minc_warn("%s(): arg '%s' not provided - defaulting to 0", sCalledFunction, argSym->name);
/* Copy zeroed MincValue union to us and then to sym. */
MincListElem zeroElem;
zeroElem.type = argSym->type;
memset(&zeroElem.val, 0, sizeof(MincValue));
copy_listelem_tree(tp, &zeroElem);
copy_tree_sym(argSym, tp);
++sArgListIndex;
}
/* compare stored NodeName with user-passed arg */
else {
// Pre-cached argument value from caller
MincListElem *argValue = &sMincList[sArgListIndex];
bool compatible = false;
switch (argValue->type) {
case MincFloatType:
case MincStringType:
case MincHandleType:
case MincListType:
if (argSym->type != argValue->type) {
minc_die("%s() arg '%s' passed as %s, expecting %s",
sCalledFunction, argSym->name, MincTypeName(argValue->type), MincTypeName(argSym->type));
}
else compatible = true;
break;
default:
assert(argValue->type != MincVoidType);
break;
}
if (compatible) {
/* Copy passed-in arg's MincValue union to us and then to sym. */
copy_listelem_tree(tp, argValue);
copy_tree_sym(argSym, tp);
}
++sArgListIndex;
}
}
break;
case NodeRet:
exct(tp->u.child[0]);
copy_tree_tree(tp, tp->u.child[0]);
assert(tp->type == tp->u.child[0]->type);
TPRINT("NodeRet throwing %p for return stmt\n", tp);
throw tp; // Cool, huh? Throws this node's body out to function's endpoint!
break;
case NodeFuncSeq:
exct(tp->u.child[0]);
exct(tp->u.child[1]);
copy_tree_tree(tp, tp->u.child[1]);
assert(tp->type == tp->u.child[1]->type);
break;
case NodeNoop:
/* do nothing */
break;
case NodeFor:
exct(tp->u.child[0]); /* init */
while (cmp(0.0, exct(tp->u.child[1])->v.number) != 0) { /* condition */
exct(tp->u.child[3]); /* execute block */
exct(tp->u.child[2]); /* prepare for next iteration */
}
break;
case NodeSeq:
exct(tp->u.child[0]);
exct(tp->u.child[1]);
break;
case NodeBlock: // NodeBlock returns void
push_scope();
exct(tp->u.child[0]);
pop_scope();
break;
case NodeDecl:
{
const char *name = tp->name; // as set by NodeDecl creator
TPRINT("-- declaring variable '%s'\n", name);
Symbol *sym = lookup(name, inCalledFunctionArgList ? ThisLevel : AnyLevel);
if (!sym) {
sym = install(name, NO);
sym->type = tp->type;
}
else {
if (sym->scope == current_scope()) {
if (inCalledFunctionArgList) {
minc_die("%s(): argument variable '%s' already used", sCalledFunction, name);
}
minc_warn("variable '%s' redefined - using existing one", name);
}
else {
if (sFunctionCallDepth == 0) {
minc_warn("variable '%s' also defined at enclosing scope", name);
}
sym = install(name, NO);
sym->type = tp->type;
}
}
tp->u.symbol = sym;
}
break;
case NodeFuncDecl:
{
const char *name = tp->name; // as set by NodeDecl creator
TPRINT("-- declaring function '%s'\n", name);
assert(current_scope() == 0); // until I allow nested functions
Symbol *sym = lookup(name, GlobalLevel); // only look at current global level
if (sym == NULL) {
sym = install(name, YES); // all functions global for now
sym->type = tp->type;
tp->u.symbol = sym;
}
else {
minc_die("function %s() is already declared", name);
}
}
break;
case NodeFuncDef:
{
// Look up symbol for function, and bind this FuncDef node to it.
TPRINT("NodeFuncDef: executing lookup node %p\n", tp->u.child[0]);
exct(tp->u.child[0]);
assert(tp->u.child[0]->u.symbol != NULL);
tp->u.child[0]->u.symbol->tree = tp;
}
break;
default:
minc_internal_error("exct: tried to execute invalid node '%s'", printNodeKind(tp->kind));
break;
} /* switch kind */
TPRINT("%s done, tp=%p, %s\n", printNodeKind(tp->kind), tp, MincTypeName(tp->type));
return tp;
}
static void
clear_list(MincListElem *list, int len)
{
ENTER();
int i;
for (i = 0; i < len; ++i) {
clear_elem(&list[i]);
}
}
static void
push_list()
{
ENTER();
if (list_stack_ptr >= MAXSTACK)
minc_die("stack overflow: too many nested function calls");
list_stack[list_stack_ptr] = sMincList;
list_len_stack[list_stack_ptr++] = sMincListLen;
sMincList = (MincListElem *) calloc(MAXDISPARGS, sizeof(MincListElem));
TPRINT("push_list: sMincList=%p at stack level %d, len %d\n", sMincList, list_stack_ptr, sMincListLen);
sMincListLen = 0;
}
static void
pop_list()
{
ENTER();
TPRINT("pop_list: sMincList=%p\n", sMincList);
clear_list(sMincList, MAXDISPARGS);
efree(sMincList);
if (list_stack_ptr == 0)
minc_die("stack underflow");
sMincList = list_stack[--list_stack_ptr];
sMincListLen = list_len_stack[list_stack_ptr];
TPRINT("pop_list: now at sMincList=%p, stack level %d, len %d\n", sMincList, list_stack_ptr, sMincListLen);
}
static void copy_value(MincValue *dest, MincDataType destType,
MincValue *src, MincDataType srcType)
{
ENTER();
if (srcType == MincHandleType && src->handle != NULL) {
ref_handle(src->handle); // ref before unref
}
else if (srcType == MincListType && src->list != NULL) {
#ifdef DEBUG_MEMORY
TPRINT("list %p refcount %d -> %d\n", src->list, src->list->refcount, src->list->refcount+1);
#endif
++src->list->refcount;
}
if (destType == MincHandleType && dest->handle != NULL) {
TPRINT("\toverwriting existing Handle value\n");
unref_handle(dest->handle); // overwriting handle, so unref
}
else if (destType == MincListType) {
TPRINT("\toverwriting existing MincList value\n");
unref_value_list(dest);
}
memcpy(dest, src, sizeof(MincValue));
}
/* This copies a Tree node's value and handles ref counting when necessary */
static void
copy_tree_tree(Tree tpdest, Tree tpsrc)
{
TPRINT("copy_tree_tree(%p, %p)\n", tpdest, tpsrc);
copy_value(&tpdest->v, tpdest->type, &tpsrc->v, tpsrc->type);
if (tpdest->type != MincVoidType && tpsrc->type != tpdest->type) {
minc_warn("Overwriting %s variable '%s' with %s", MincTypeName(tpdest->type), tpdest->name, MincTypeName(tpsrc->type));
}
tpdest->type = tpsrc->type;
TPRINT("dest: ");
print_value(&tpdest->v, tpdest->type);
}
/* This copies a Symbol's value and handles ref counting when necessary */
static void
copy_sym_tree(Tree tpdest, Symbol *src)
{
TPRINT("copy_sym_tree(%p, %p)\n", tpdest, src);
assert(src->scope != -1); // we accessed a variable after leaving its scope!
copy_value(&tpdest->v, tpdest->type, &src->v, src->type);
if (tpdest->type != MincVoidType && src->type != tpdest->type) {
minc_warn("Overwriting %s variable '%s' with %s", MincTypeName(tpdest->type), tpdest->name, MincTypeName(src->type));
}
tpdest->type = src->type;
TPRINT("dest: ");
print_value(&tpdest->v, tpdest->type);
}
static void
copy_tree_sym(Symbol *dest, Tree tpsrc)
{
TPRINT("copy_tree_sym(%p, %p)\n", dest, tpsrc);
assert(dest->scope != -1); // we accessed a variable after leaving its scope!
copy_value(&dest->v, dest->type, &tpsrc->v, tpsrc->type);
if (dest->type != MincVoidType && tpsrc->type != dest->type) {
minc_warn("Overwriting %s variable '%s' with %s", MincTypeName(dest->type), dest->name, MincTypeName(tpsrc->type));
}
dest->type = tpsrc->type;
}
static void
copy_tree_listelem(MincListElem *dest, Tree tpsrc)
{
TPRINT("copy_tree_listelem(%p, %p)\n", dest, tpsrc);
copy_value(&dest->val, dest->type, &tpsrc->v, tpsrc->type);
dest->type = tpsrc->type;
}
static void
copy_listelem_tree(Tree tpdest, MincListElem *esrc)
{
TPRINT("copy_listelem_tree(%p, %p)\n", tpdest, esrc);
copy_value(&tpdest->v, tpdest->type, &esrc->val, esrc->type);
tpdest->type = esrc->type;
}
static void
copy_listelem_elem(MincListElem *edest, MincListElem *esrc)
{
TPRINT("copy_listelem_elem(%p, %p)\n", edest, esrc);
copy_value(&edest->val, edest->type, &esrc->val, esrc->type);
edest->type = esrc->type;
}
/* This recursive function frees space. */
void
free_tree(Tree tp)
{
if (tp == NULL)
return;
#ifdef DEBUG_MEMORY
TPRINT("entering free_tree(%p) (%s)\n", tp, printNodeKind(tp->kind));
#endif
switch (tp->kind) {
case NodeZero:
break;
case NodeSeq:
case NodeFuncSeq:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeStore:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeList:
free_tree(tp->u.child[0]);
break;
case NodeListElem:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeEmptyListElem:
break;
case NodeSubscriptRead:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeSubscriptWrite:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
break;
case NodeOpAssign:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeName:
case NodeAutoName:
break;
case NodeDecl:
break;
case NodeFuncDecl:
break;
case NodeBlock:
free_tree(tp->u.child[0]);
break;
case NodeString:
break;
case NodeConstf:
break;
case NodeFuncDef:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
break;
case NodeArgListElem:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeArgList:
free_tree(tp->u.child[0]);
break;
case NodeRet:
free_tree(tp->u.child[0]);
break;
case NodeCall:
free_tree(tp->u.child[0]);
break;
case NodeNot:
free_tree(tp->u.child[0]);
break;
case NodeAnd:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeRelation:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeOperator:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeUnaryOperator:
free_tree(tp->u.child[0]);
break;
case NodeOr:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeIf:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeIfElse:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
break;
case NodeWhile:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
break;
case NodeNoop:
break;
case NodeFor:
free_tree(tp->u.child[0]);
free_tree(tp->u.child[1]);
free_tree(tp->u.child[2]);
free_tree(tp->u.child[3]);
break;
default:
minc_internal_error("free_tree: tried to destroy invalid node '%s'", printNodeKind(tp->kind));
break;
} /* switch kind */
if (tp->type == MincHandleType) {
unref_handle(tp->v.handle);
}
else if (tp->type == MincListType) {
unref_value_list(&tp->v);
}
tp->type = MincVoidType; // To prevent double-free
efree(tp); /* actually free space */
#ifdef DEBUG_MEMORY
--numTrees;
TPRINT("[%d trees left]\n", numTrees);
#endif
// TPRINT("leaving free_tree(%p)\n", tp);
}
void print_tree(Tree tp)
{
#ifdef DEBUG
rtcmix_print("Tree %p: %s type: %d\n", tp, printNodeKind(tp->kind), tp->type);
if (tp->kind == NodeName) {
rtcmix_print("Symbol:\n");
print_symbol(tp->u.symbol);
}
else if (tp->type == MincVoidType && tp->u.child[0] != NULL) {
rtcmix_print("Child 0:\n");
print_tree(tp->u.child[0]);
}
#endif
}
void print_symbol(struct symbol * s)
{
rtcmix_print("Symbol %p: '%s' scope: %d type: %d\n", s, s->name, s->scope, s->type);
}
void print_value(MincValue *v, MincDataType type)
{
switch (type) {
case MincFloatType:
TPRINT("%f\n", v->number);
break;
case MincHandleType:
TPRINT("%p\n", v->handle);
break;
case MincListType:
TPRINT("%p\n", v->list);
break;
case MincStringType:
TPRINT("%s\n", v->string);
break;
case MincVoidType:
TPRINT("void\n");
break;
}
}
void
clear_elem(MincListElem *elem)
{
if (elem->type == MincListType) {
TPRINT("clear_elem(%p)\n", elem);
unref_value_list(&elem->val);
}
else if (elem->type == MincHandleType) {
TPRINT("clear_elem(%p)\n", elem);
unref_handle(elem->val.handle);
}
}
void
unref_value_list(MincValue *value)
{
if (value->list == NULL)
return;
#ifdef DEBUG_MEMORY
TPRINT("unref_value_list(%p) [%d -> %d]\n", value->list, value->list->refcount, value->list->refcount-1);
#endif
assert(value->list->refcount > 0);
if (--value->list->refcount == 0) {
if (value->list->data != NULL) {
int e;
TPRINT("\tfreeing MincList data %p...\n", value->list->data);
for (e = 0; e < value->list->len; ++e) {
MincListElem *elem = &value->list->data[e];
clear_elem(elem);
}
efree(value->list->data);
value->list->data = NULL;
TPRINT("\tdone\n");
}
TPRINT("\tfreeing MincList %p\n", value->list);
efree(value->list);
}
}
|
/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 1999-2000 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache\@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation, and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com . For more information
* on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
/**
* This file contains code to build the DOM tree. It registers a document
* handler with the scanner. In these handler methods, appropriate DOM nodes
* are created and added to the DOM tree.
*
* $Id$
*
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <sax/EntityResolver.hpp>
#include <util/XMLUniDefs.hpp>
#include <sax/ErrorHandler.hpp>
#include <sax/SAXParseException.hpp>
#include <framework/XMLNotationDecl.hpp>
#include <util/IOException.hpp>
#include <internal/XMLScanner.hpp>
#include <validators/DTD/DTDValidator.hpp>
#include <parsers/DOMParser.hpp>
#include <dom/ElementImpl.hpp>
#include <dom/AttrImpl.hpp>
#include <dom/TextImpl.hpp>
#include <dom/DocumentImpl.hpp>
#include <dom/DocumentTypeImpl.hpp>
#include <dom/EntityImpl.hpp>
#include <dom/NotationImpl.hpp>
#include <dom/NamedNodeMapImpl.hpp>
#include <dom/NodeIDMap.hpp>
#include <validators/DTD/ContentSpecNode.hpp>
#include <validators/DTD/DTDAttDefList.hpp>
// ---------------------------------------------------------------------------
// DOMParser: Constructors and Destructor
// ---------------------------------------------------------------------------
DOMParser::DOMParser(XMLValidator* const valToAdopt) :
fErrorHandler(0)
, fEntityResolver(0)
, fCreateEntityReferenceNodes(false)
, fToCreateXMLDeclTypeNode(false)
, fIncludeIgnorableWhitespace(true)
, fNodeStack(0)
, fScanner(0)
, fOldDocTypeHandler(0)
, fValidator(valToAdopt)
{
// Create the validator if one was not provided
if (!fValidator)
fValidator = new DTDValidator;
//If the user already registered the doctypehandler then chain it
fOldDocTypeHandler = ((DTDValidator*)fValidator)->getDocTypeHandler();
//register the new doctypehandler
((DTDValidator*)fValidator)->setDocTypeHandler(this);
//
// Create a scanner and tell it what validator to use. Then set us
// as the document event handler so we can fill the DOM document.
//
fScanner = new XMLScanner(fValidator);
fScanner->setDocHandler(this);
fNodeStack = new ValueStackOf<DOM_Node>(64);
this->reset();
}
DOMParser::~DOMParser()
{
delete fNodeStack;
delete fScanner;
delete fValidator;
}
void DOMParser::reset()
{
//
// Note: DOM Documents are reference counted. Doing this assignment
// will cause the old one to go away unless application code is also
// holding a reference to it.
//
fDocument = DOM_Document::createDocument();
resetDocType();
fCurrentParent = 0;
fCurrentNode = 0;
fParseInProgress = false;
fWithinElement = false;
fNodeStack->removeAllElements();
};
// ---------------------------------------------------------------------------
// DOMParser: Getter methods
// ---------------------------------------------------------------------------
const XMLValidator& DOMParser::getValidator() const
{
return *fValidator;
}
bool DOMParser::getDoNamespaces() const
{
return fScanner->getDoNamespaces();
}
bool DOMParser::getExitOnFirstFatalError() const
{
return fScanner->getExitOnFirstFatal();
}
DOMParser::ValSchemes DOMParser::getValidationScheme() const
{
const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
if (scheme == XMLScanner::Val_Always)
return Val_Always;
else if (scheme == XMLScanner::Val_Never)
return Val_Never;
return Val_Auto;
}
// ---------------------------------------------------------------------------
// DOMParser: Setter methods
// ---------------------------------------------------------------------------
void DOMParser::setDoNamespaces(const bool newState)
{
fScanner->setDoNamespaces(newState);
}
void DOMParser::setErrorHandler(ErrorHandler* const handler)
{
fErrorHandler = handler;
if (fErrorHandler)
{
fScanner->setErrorReporter(this);
fValidator->setErrorReporter(this);
}
else
{
fScanner->setErrorReporter(0);
fValidator->setErrorReporter(0);
}
}
void DOMParser::setEntityResolver(EntityResolver* const handler)
{
fEntityResolver = handler;
if (fEntityResolver)
fScanner->setEntityHandler(this);
else
fScanner->setEntityHandler(0);
}
void DOMParser::setExitOnFirstFatalError(const bool newState)
{
fScanner->setExitOnFirstFatal(newState);
}
void DOMParser::setValidationScheme(const ValSchemes newScheme)
{
if (newScheme == Val_Never)
fScanner->setValidationScheme(XMLScanner::Val_Never);
else if (newScheme == Val_Always)
fScanner->setValidationScheme(XMLScanner::Val_Always);
else
fScanner->setValidationScheme(XMLScanner::Val_Auto);
}
// ---------------------------------------------------------------------------
// DOMParser: Parsing methods
// ---------------------------------------------------------------------------
void DOMParser::parse(const InputSource& source, const bool reuseValidator)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(source, reuseValidator);
fParseInProgress = false;
}
catch(...)
{
fParseInProgress = false;
throw;
}
}
void DOMParser::parse(const XMLCh* const systemId, const bool reuseValidator)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(systemId, reuseValidator);
fParseInProgress = false;
}
catch(...)
{
fParseInProgress = false;
throw;
}
}
void DOMParser::parse(const char* const systemId, const bool reuseValidator)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(systemId, reuseValidator);
fParseInProgress = false;
}
catch(...)
{
fParseInProgress = false;
throw;
}
}
// ---------------------------------------------------------------------------
// DOMParser: Progressive parse methods
// ---------------------------------------------------------------------------
bool DOMParser::parseFirst( const XMLCh* const systemId
, XMLPScanToken& toFill
, const bool reuseValidator)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
return fScanner->scanFirst(systemId, toFill, reuseValidator);
}
bool DOMParser::parseFirst( const char* const systemId
, XMLPScanToken& toFill
, const bool reuseValidator)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
return fScanner->scanFirst(systemId, toFill, reuseValidator);
}
bool DOMParser::parseFirst( const InputSource& source
, XMLPScanToken& toFill
, const bool reuseValidator)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
return fScanner->scanFirst(source, toFill, reuseValidator);
}
bool DOMParser::parseNext(XMLPScanToken& token)
{
return fScanner->scanNext(token);
}
void DOMParser::parseReset(XMLPScanToken& token)
{
// Reset the scanner, and then reset the parser
fScanner->scanReset(token);
reset();
}
// ---------------------------------------------------------------------------
// DOMParser: Implementation of the XMLErrorReporter interface
// ---------------------------------------------------------------------------
void DOMParser::error( const unsigned int code
, const XMLCh* const msgDomain
, const XMLErrorReporter::ErrTypes errType
, const XMLCh* const errorText
, const XMLCh* const systemId
, const XMLCh* const publicId
, const unsigned int lineNum
, const unsigned int colNum)
{
SAXParseException toThrow = SAXParseException
(
errorText
, publicId
, systemId
, lineNum
, colNum
);
//
// If there is an error handler registered, call it, otherwise ignore
// all but the fatal errors.
//
if (!fErrorHandler)
{
if (errType == XMLErrorReporter::ErrType_Fatal)
throw toThrow;
return;
}
if (errType == XMLErrorReporter::ErrType_Warning)
fErrorHandler->warning(toThrow);
else if (errType >= XMLErrorReporter::ErrType_Fatal)
fErrorHandler->fatalError(toThrow);
else
fErrorHandler->error(toThrow);
}
void DOMParser::resetErrors()
{
}
// ---------------------------------------------------------------------------
// DOMParser: Implementation of XMLEntityHandler interface
// ---------------------------------------------------------------------------
InputSource*
DOMParser::resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId)
{
//
// Just map it to the SAX entity resolver. If there is not one installed,
// return a null pointer to cause the default resolution.
//
if (fEntityResolver)
return fEntityResolver->resolveEntity(publicId, systemId);
return 0;
}
// ---------------------------------------------------------------------------
// DOMParser: Implementation of XMLDocumentHandler interface
// ---------------------------------------------------------------------------
void DOMParser::docCharacters( const XMLCh* const chars
, const unsigned int length
, const bool cdataSection)
{
// Ignore chars outside of content
if (!fWithinElement)
return;
if (cdataSection == true)
{
DOM_CDATASection node = fDocument.createCDATASection
(
DOMString(chars, length)
);
fCurrentParent.appendChild(node);
fCurrentNode = node;
}
else
{
if (fCurrentNode.getNodeType() == DOM_Node::TEXT_NODE)
{
DOM_Text node = (DOM_Text&)fCurrentNode;
node.appendData(DOMString(chars, length));
}
else
{
DOM_Text node = fDocument.createTextNode(DOMString(chars, length));
//If the node type is entityRef then set the readOnly flag to false before appending node
bool oldReadFlag;
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
oldReadFlag = fCurrentParent.fImpl->isReadOnly();
fCurrentParent.fImpl->isReadOnly(false);
}
fCurrentParent.appendChild(node);
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
fCurrentParent.fImpl->isReadOnly(oldReadFlag);
}
fCurrentNode = node;
}
}
}
void DOMParser::docComment(const XMLCh* const comment)
{
DOM_Comment dcom = fDocument.createComment(comment);
fCurrentParent.appendChild(dcom);
fCurrentNode = dcom;
}
void DOMParser::docPI( const XMLCh* const target
, const XMLCh* const data)
{
DOM_ProcessingInstruction pi = fDocument.createProcessingInstruction
(
target
, data
);
fCurrentParent.appendChild(pi);
fCurrentNode = pi;
}
void DOMParser::endEntityReference(const XMLEntityDecl& entDecl)
{
if (fCreateEntityReferenceNodes == true)
{
fCurrentParent = fNodeStack->pop();
fCurrentNode = fCurrentParent;
}
}
void DOMParser::endElement( const XMLElementDecl& elemDecl
, const unsigned int urlId
, const bool isRoot)
{
fCurrentNode = fCurrentParent;
fCurrentParent = fNodeStack->pop();
// If we've hit the end of content, clear the flag
if (fNodeStack->empty())
fWithinElement = false;
}
void DOMParser::ignorableWhitespace(const XMLCh* const chars
, const unsigned int length
, const bool cdataSection)
{
// Ignore chars before the root element
if (!fWithinElement || !fIncludeIgnorableWhitespace)
return;
if (fCurrentNode.getNodeType() == DOM_Node::TEXT_NODE)
{
DOM_Text node = (DOM_Text&)fCurrentNode;
node.appendData(DOMString(chars, length));
}
else
{
DOM_Text node = fDocument.createTextNode(DOMString(chars, length));
TextImpl *text = (TextImpl *) node.fImpl;
text -> setIgnorableWhitespace(true);
//If the node type is entityRef then set the readOnly flag to false before appending node
bool oldReadFlag;
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
oldReadFlag = fCurrentParent.fImpl->isReadOnly();
fCurrentParent.fImpl->isReadOnly(false);
}
fCurrentParent.appendChild(node);
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
fCurrentParent.fImpl->isReadOnly(oldReadFlag);
}
fCurrentNode = node;
}
}
void DOMParser::resetDocument()
{
//
// The reset methods are called before a new parse event occurs.
// Reset this parsers state to clear out anything that may be left
// from a previous use, in particular the DOM document itself.
//
this->reset();
}
void DOMParser::startDocument()
{
// Just set the document as the current parent and current node
fCurrentParent = fDocument;
fCurrentNode = fDocument;
}
void DOMParser::startElement(const XMLElementDecl& elemDecl
, const unsigned int urlId
, const XMLCh* const elemPrefix
, const RefVectorOf<XMLAttr>& attrList
, const unsigned int attrCount
, const bool isEmpty
, const bool isRoot)
{
DOM_Element elem;
DocumentImpl *docImpl = (DocumentImpl *)fDocument.fImpl;
if (fScanner -> getDoNamespaces()) { //DOM Level 2, doNamespaces on
unsigned int globalNSid = fValidator -> getGlobalNamespaceId();
XMLBuffer buf;
DOMString namespaceURI = 0;
if (urlId != globalNSid) { //TagName has a prefix
fValidator -> getURIText(urlId, buf); //get namespaceURI
namespaceURI = DOMString(buf.getRawBuffer());
}
elem = fDocument.createElementNS(namespaceURI, elemDecl.getFullName());
ElementImpl *elemImpl = (ElementImpl *) elem.fImpl;
for (unsigned int index = 0; index < attrCount; ++index) {
static const XMLCh XMLNS[] = {
chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull
};
const XMLAttr* oneAttrib = attrList.elementAt(index);
unsigned int attrURIId = oneAttrib -> getURIId();
namespaceURI = 0;
if (!XMLString::compareString(oneAttrib -> getName(), XMLNS)) //for xmlns=...
attrURIId = fValidator -> getXMLNSNamespaceId();
if (attrURIId != globalNSid) { //TagName has a prefix
fValidator -> getURIText(attrURIId, buf); //get namespaceURI
namespaceURI = DOMString(buf.getRawBuffer());
}
AttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
oneAttrib -> getValue());
// Attributes of type ID. If this is one, add it to the hashtable of IDs
// that is constructed for use by GetElementByID().
//
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (docImpl->fNodeIDMap == 0)
docImpl->fNodeIDMap = new NodeIDMap(500);
docImpl->fNodeIDMap->add(attr);
attr->isIdAttr(true);
}
attr->setSpecified(oneAttrib->getSpecified());
}
}
else { //DOM Level 1
elem = fDocument.createElement(elemDecl.getFullName());
ElementImpl *elemImpl = (ElementImpl *) elem.fImpl;
for (unsigned int index = 0; index < attrCount; ++index) {
const XMLAttr* oneAttrib = attrList.elementAt(index);
AttrImpl *attr = elemImpl->setAttribute(oneAttrib->getName(), oneAttrib->getValue());
attr->setSpecified(oneAttrib->getSpecified());
// Attributes of type ID. If this is one, add it to the hashtable of IDs
// that is constructed for use by GetElementByID().
//
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (docImpl->fNodeIDMap == 0)
docImpl->fNodeIDMap = new NodeIDMap(500);
docImpl->fNodeIDMap->add(attr);
attr->isIdAttr(true);
}
}
}
//If the node type is entityRef then set the readOnly flag to false before appending node
bool oldReadFlag;
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
oldReadFlag = fCurrentParent.fImpl->isReadOnly();
fCurrentParent.fImpl->isReadOnly(false);
}
fCurrentParent.appendChild(elem);
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
fCurrentParent.fImpl->isReadOnly(oldReadFlag);
}
fNodeStack->push(fCurrentParent);
fCurrentParent = elem;
fCurrentNode = elem;
fWithinElement = true;
// If an empty element, do end right now (no endElement() will be called)
if (isEmpty)
endElement(elemDecl, urlId, isRoot);
}
void DOMParser::startEntityReference(const XMLEntityDecl& entDecl)
{
if (fCreateEntityReferenceNodes == true)
{
DOMString entName(entDecl.getName());
DOM_EntityReference er = fDocument.createEntityReference(entName);
fCurrentParent.appendChild(er);
fNodeStack->push(fCurrentParent);
fCurrentParent = er;
fCurrentNode = er;
// this entityRef needs to be stored in Entity map too.
// We'd decide later whether the entity nodes should be created by a
// separated method in parser or not. For now just stick it in if
// the ref nodes are created
EntityImpl* entity = (EntityImpl*)fDocumentType->entities->getNamedItem(entName);
entity->setEntityRef((EntityReferenceImpl*)er.fImpl);
}
}
void DOMParser::XMLDecl(const XMLCh* const version
, const XMLCh* const encoding
, const XMLCh* const standalone
, const XMLCh* const actualEncStr)
{
//This is a non-standard extension to creating XMLDecl type nodes and attching to DOM Tree
// currently this flag it set to false unless user explicitly asks for it
// Needs to be revisited after W3C specs are laid out on this issue.
if (fToCreateXMLDeclTypeNode) {
DOMString ver(version);
DOMString enc(encoding);
DOMString std(standalone);
DOM_XMLDecl xmlDecl = fDocument.createXMLDecl(ver, enc, std);
fCurrentParent.appendChild(xmlDecl);
}
}
// ---------------------------------------------------------------------------
// DOMParser: Deprecated methods
// ---------------------------------------------------------------------------
bool DOMParser::getDoValidation() const
{
//
// We don't want to tie the public parser classes to the enum used
// by the scanner, so we use a separate one and map.
//
// DON'T mix the new and old methods!!
//
const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
if (scheme == XMLScanner::Val_Always)
return true;
return false;
}
void DOMParser::setDoValidation(const bool newState)
{
fScanner->setDoValidation
(
newState ? XMLScanner::Val_Always : XMLScanner::Val_Never
);
}
//doctypehandler interfaces
void DOMParser::attDef
(
const DTDElementDecl& elemDecl
, const DTDAttDef& attDef
, const bool ignoring
)
{
if(fOldDocTypeHandler)
{
fOldDocTypeHandler->attDef(elemDecl,attDef, ignoring );
}
if (fDocumentType->isIntSubsetReading())
{
DOMString attString;
if (elemDecl.hasAttDefs())
{
attString.appendData(chOpenAngle);
attString.appendData(chBang);
attString.appendData(XMLUni::fgAttListString);
attString.appendData(chSpace);
attString.appendData(elemDecl.getFullName());
attString.appendData(chSpace);
attString.appendData(attDef.getFullName());
// Get the type and display it
const XMLAttDef::AttTypes type = attDef.getType();
switch(type)
{
case XMLAttDef::CData :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgCDATAString);
break;
case XMLAttDef::ID :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgIDString);
break;
case XMLAttDef::IDRef :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgIDRefString);
break;
case XMLAttDef::IDRefs :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgIDRefsString);
break;
case XMLAttDef::Entity :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgEntityString);
break;
case XMLAttDef::Entities :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgEntitiesString);
break;
case XMLAttDef::NmToken :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgNmTokenString);
break;
case XMLAttDef::NmTokens :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgNmTokensString);
break;
case XMLAttDef::Notation :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgNotationString);
break;
case XMLAttDef::Enumeration :
attString.appendData(chSpace);
// attString.appendData(XMLUni::fgEnumerationString);
const XMLCh* enumString = attDef.getEnumeration();
int length = XMLString::stringLen(enumString);
if (length > 0) {
DOMString anotherEnumString;
anotherEnumString.appendData(chOpenParen );
for(int i=0; i<length; i++) {
if (enumString[i] == chSpace)
anotherEnumString.appendData(chPipe);
else
anotherEnumString.appendData(enumString[i]);
}
anotherEnumString.appendData(chCloseParen);
attString.appendData(anotherEnumString);
enumString = attDef.getValue();
if ( enumString != 0) {
attString.appendData(chSpace);
attString.appendData(chDoubleQuote);
attString.appendData(XMLString::transcode(attDef.getValue()));
attString.appendData(chDoubleQuote);
}
}
break;
}
//get te default types of the attlist
const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
switch(def)
{
case XMLAttDef::Required :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgRequiredString);
break;
case XMLAttDef::Implied :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgImpliedString);
break;
case XMLAttDef::Fixed :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgFixedString);
break;
}
attString.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(attString);
}
}
}
void DOMParser::doctypeComment
(
const XMLCh* const comment
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypeComment(comment);
}
if (fDocumentType->isIntSubsetReading())
{
if (comment != 0)
{
DOMString comString;
comString.appendData(XMLUni::fgCommentString);
comString.appendData(chSpace);
comString.appendData(comment);
comString.appendData(chSpace);
comString.appendData(chDash);
comString.appendData(chDash);
comString.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(comString);
}
}
}
void DOMParser::doctypeDecl
(
const DTDElementDecl& elemDecl
, const XMLCh* const publicId
, const XMLCh* const systemId
, const bool hasIntSubset
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypeDecl(elemDecl, publicId, systemId, hasIntSubset);
}
DOM_DocumentType dt;
dt = fDocument.getImplementation().createDocumentType(elemDecl.getFullName(), publicId, systemId);
fDocumentType = (DocumentTypeImpl*)dt.fImpl;
((DocumentImpl*)fDocument.fImpl)->setDocumentType(fDocumentType);
populateDocumentType(); // Add the entities and notations to this DocType.
}
void DOMParser::doctypePI
(
const XMLCh* const target
, const XMLCh* const data
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypePI(target, data);
}
if (fDocumentType->isIntSubsetReading())
{
//add these chars to internalSubset variable
DOMString pi;
pi.appendData(chOpenAngle);
pi.appendData(chQuestion);
pi.appendData(target);
pi.appendData(chSpace);
pi.appendData(data);
pi.appendData(chQuestion);
pi.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(pi);
}
}
void DOMParser::doctypeWhitespace
(
const XMLCh* const chars
, const unsigned int length
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypeWhitespace(chars, length);
}
if (fDocumentType->isIntSubsetReading())
fDocumentType->internalSubset.appendData(chars);
}
void DOMParser::elementDecl
(
const DTDElementDecl& decl
, const bool isIgnored
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->elementDecl(decl, isIgnored);
}
if (fDocumentType->isIntSubsetReading())
{
DOMString elemDecl;
elemDecl.appendData(chOpenAngle);
elemDecl.appendData(chBang);
elemDecl.appendData(XMLUni::fgElemString);
elemDecl.appendData(chSpace);
elemDecl.appendData(decl.getFullName());
//get the ContentSpec information
const XMLCh* contentModel = decl.getFormattedContentModel(*fValidator);
if (contentModel != 0) {
elemDecl.appendData(chSpace);
elemDecl.appendData(contentModel);
}
elemDecl.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(elemDecl);
}
}
void DOMParser::endAttList
(
const DTDElementDecl& elemDecl
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->endAttList(elemDecl);
}
// this section sets up default attributes.
// default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
// default attribute data attached to the document is used to conform to the
// DOM spec regarding creating element nodes & removing attributes with default values
// see DocumentTypeImpl
if (elemDecl.hasAttDefs())
{
XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
XMLAttDef* attr = 0;
AttrImpl* insertAttr = 0;
DOM_Element dom_elem = fDocument.createElement(elemDecl.getFullName());
ElementImpl* elem = (ElementImpl*)(dom_elem.fImpl);
static const XMLCh XMLNS[] = {chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
while (defAttrs->hasMoreElements())
{
attr = &defAttrs->nextElement();
if (attr->getValue() != null)
{
if (fScanner->getDoNamespaces())
{
// Namespaces is turned on...
unsigned int attrURIId = attr->getId();
XMLBuffer buf;
DOMString namespaceURI = 0;
if (!XMLString::compareString(attr->getFullName(), XMLNS)) //for xmlns=...
attrURIId = fValidator->getXMLNSNamespaceId();
if (attrURIId != fValidator->getGlobalNamespaceId()) { //TagName has a prefix
fValidator->getURIText(attrURIId, buf); //get namespaceURI
namespaceURI = DOMString(buf.getRawBuffer());
}
insertAttr = elem->setAttributeNS(namespaceURI, attr->getFullName(), attr->getValue());
insertAttr->setSpecified(false);
}
else
{
// Namespaces is turned off...
insertAttr = new AttrImpl((DocumentImpl*)fDocument.fImpl, attr->getFullName());
insertAttr->setValue(attr->getValue());
elem->setAttributeNode(insertAttr);
insertAttr->setSpecified(false);
}
}
}
fDocumentType->getElements()->setNamedItem(elem);
}
}
void DOMParser::endIntSubset()
{
fDocumentType->intSubsetReading = false;
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->endIntSubset();
}
}
void DOMParser::endExtSubset()
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->endExtSubset();
}
}
void DOMParser::entityDecl
(
const DTDEntityDecl& entityDecl
, const bool isPEDecl
, const bool isIgnored
)
{
EntityImpl* entity = ((DocumentImpl*)fDocument.fImpl)->createEntity(entityDecl.getName());
entity->setPublicId(entityDecl.getPublicId());
entity->setSystemId(entityDecl.getSystemId());
entity->setNotationName(entityDecl.getNotationName());
fDocumentType->entities->setNamedItem( entity );
if (fDocumentType->isIntSubsetReading())
{
//add thes chars to internalSubset variable
DOMString entityName;
entityName.appendData(chOpenAngle);
entityName.appendData(chBang);
entityName.appendData(XMLUni::fgEntityString);
entityName.appendData(chSpace);
entityName.appendData(entityDecl.getName());
DOMString id = entity->getPublicId();
if (id != 0) {
entityName.appendData(chSpace);
entityName.appendData(XMLUni::fgPubIDString);
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
id = entity->getSystemId();
if (id != 0) {
entityName.appendData(chSpace);
entityName.appendData(XMLUni::fgSysIDString);
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
id = entity->getNotationName();
if (id != 0) {
entityName.appendData(chSpace);
entityName.appendData(XMLUni::fgNDATAString);
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
id = entityDecl.getValue();
if (id !=0) {
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
entityName.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(entityName);
}
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->entityDecl(entityDecl, isPEDecl, isIgnored);
}
}
void DOMParser::resetDocType()
{
fDocumentType = null;
}
void DOMParser::notationDecl
(
const XMLNotationDecl& notDecl
, const bool isIgnored
)
{
NotationImpl* notation = ((DocumentImpl*)fDocument.fImpl)->createNotation(notDecl.getName());
notation->setPublicId(notDecl.getPublicId());
notation->setPublicId(notDecl.getPublicId());
fDocumentType->notations->setNamedItem( notation );
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->notationDecl(notDecl, isIgnored);
}
}
void DOMParser::startAttList
(
const DTDElementDecl& elemDecl
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->startAttList(elemDecl);
}
}
void DOMParser::startIntSubset()
{
fDocumentType->intSubsetReading = true;
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->startIntSubset();
}
}
void DOMParser::startExtSubset()
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->startExtSubset();
}
}
void DOMParser::TextDecl
(
const XMLCh* const versionStr
, const XMLCh* const encodingStr
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->TextDecl(versionStr, encodingStr);
}
}
// to populate the entities in the documentType
void DOMParser::populateDocumentType()
{
if (fDocumentType == null)
return;
NameIdPoolEnumerator<DTDEntityDecl> entityPoolEnum = ((DTDValidator*)fValidator)->getEntityEnumerator();
while(entityPoolEnum.hasMoreElements()) {
DTDEntityDecl* entityDecl = &entityPoolEnum.nextElement();
EntityImpl* entity = ((DocumentImpl*)fDocument.fImpl)->createEntity(entityDecl->getName());
entity->setPublicId(entityDecl->getPublicId());
entity->setSystemId(entityDecl->getSystemId());
entity->setNotationName(entityDecl->getNotationName());
fDocumentType->entities->setNamedItem( entity );
}
NameIdPoolEnumerator<XMLNotationDecl> notationPoolEnum = ((DTDValidator*)fValidator)->getNotationEnumerator();
while(notationPoolEnum.hasMoreElements()) {
XMLNotationDecl* notationDecl = ¬ationPoolEnum.nextElement();
NotationImpl* notation = ((DocumentImpl*)fDocument.fImpl)->createNotation(notationDecl->getName());
notation->setPublicId(notationDecl->getPublicId());
notation->setPublicId(notationDecl->getPublicId());
fDocumentType->notations->setNamedItem( notation );
}
}
DOMParser MemoryLeak fixed. Occured when a document redefined the
a builtin entity, e.g. <.
git-svn-id: 3ec853389310512053d525963cab269c063bb453@172415 13f79535-47bb-0310-9956-ffa450edef68
/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 1999-2000 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache\@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation, and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com . For more information
* on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
/**
* This file contains code to build the DOM tree. It registers a document
* handler with the scanner. In these handler methods, appropriate DOM nodes
* are created and added to the DOM tree.
*
* $Id$
*
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <sax/EntityResolver.hpp>
#include <util/XMLUniDefs.hpp>
#include <sax/ErrorHandler.hpp>
#include <sax/SAXParseException.hpp>
#include <framework/XMLNotationDecl.hpp>
#include <util/IOException.hpp>
#include <internal/XMLScanner.hpp>
#include <validators/DTD/DTDValidator.hpp>
#include <parsers/DOMParser.hpp>
#include <dom/ElementImpl.hpp>
#include <dom/AttrImpl.hpp>
#include <dom/TextImpl.hpp>
#include <dom/DocumentImpl.hpp>
#include <dom/DocumentTypeImpl.hpp>
#include <dom/EntityImpl.hpp>
#include <dom/NotationImpl.hpp>
#include <dom/NamedNodeMapImpl.hpp>
#include <dom/NodeIDMap.hpp>
#include <validators/DTD/ContentSpecNode.hpp>
#include <validators/DTD/DTDAttDefList.hpp>
// ---------------------------------------------------------------------------
// DOMParser: Constructors and Destructor
// ---------------------------------------------------------------------------
DOMParser::DOMParser(XMLValidator* const valToAdopt) :
fErrorHandler(0)
, fEntityResolver(0)
, fCreateEntityReferenceNodes(false)
, fToCreateXMLDeclTypeNode(false)
, fIncludeIgnorableWhitespace(true)
, fNodeStack(0)
, fScanner(0)
, fOldDocTypeHandler(0)
, fValidator(valToAdopt)
{
// Create the validator if one was not provided
if (!fValidator)
fValidator = new DTDValidator;
//If the user already registered the doctypehandler then chain it
fOldDocTypeHandler = ((DTDValidator*)fValidator)->getDocTypeHandler();
//register the new doctypehandler
((DTDValidator*)fValidator)->setDocTypeHandler(this);
//
// Create a scanner and tell it what validator to use. Then set us
// as the document event handler so we can fill the DOM document.
//
fScanner = new XMLScanner(fValidator);
fScanner->setDocHandler(this);
fNodeStack = new ValueStackOf<DOM_Node>(64);
this->reset();
}
DOMParser::~DOMParser()
{
delete fNodeStack;
delete fScanner;
delete fValidator;
}
void DOMParser::reset()
{
//
// Note: DOM Documents are reference counted. Doing this assignment
// will cause the old one to go away unless application code is also
// holding a reference to it.
//
fDocument = DOM_Document::createDocument();
resetDocType();
fCurrentParent = 0;
fCurrentNode = 0;
fParseInProgress = false;
fWithinElement = false;
fNodeStack->removeAllElements();
};
// ---------------------------------------------------------------------------
// DOMParser: Getter methods
// ---------------------------------------------------------------------------
const XMLValidator& DOMParser::getValidator() const
{
return *fValidator;
}
bool DOMParser::getDoNamespaces() const
{
return fScanner->getDoNamespaces();
}
bool DOMParser::getExitOnFirstFatalError() const
{
return fScanner->getExitOnFirstFatal();
}
DOMParser::ValSchemes DOMParser::getValidationScheme() const
{
const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
if (scheme == XMLScanner::Val_Always)
return Val_Always;
else if (scheme == XMLScanner::Val_Never)
return Val_Never;
return Val_Auto;
}
// ---------------------------------------------------------------------------
// DOMParser: Setter methods
// ---------------------------------------------------------------------------
void DOMParser::setDoNamespaces(const bool newState)
{
fScanner->setDoNamespaces(newState);
}
void DOMParser::setErrorHandler(ErrorHandler* const handler)
{
fErrorHandler = handler;
if (fErrorHandler)
{
fScanner->setErrorReporter(this);
fValidator->setErrorReporter(this);
}
else
{
fScanner->setErrorReporter(0);
fValidator->setErrorReporter(0);
}
}
void DOMParser::setEntityResolver(EntityResolver* const handler)
{
fEntityResolver = handler;
if (fEntityResolver)
fScanner->setEntityHandler(this);
else
fScanner->setEntityHandler(0);
}
void DOMParser::setExitOnFirstFatalError(const bool newState)
{
fScanner->setExitOnFirstFatal(newState);
}
void DOMParser::setValidationScheme(const ValSchemes newScheme)
{
if (newScheme == Val_Never)
fScanner->setValidationScheme(XMLScanner::Val_Never);
else if (newScheme == Val_Always)
fScanner->setValidationScheme(XMLScanner::Val_Always);
else
fScanner->setValidationScheme(XMLScanner::Val_Auto);
}
// ---------------------------------------------------------------------------
// DOMParser: Parsing methods
// ---------------------------------------------------------------------------
void DOMParser::parse(const InputSource& source, const bool reuseValidator)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(source, reuseValidator);
fParseInProgress = false;
}
catch(...)
{
fParseInProgress = false;
throw;
}
}
void DOMParser::parse(const XMLCh* const systemId, const bool reuseValidator)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(systemId, reuseValidator);
fParseInProgress = false;
}
catch(...)
{
fParseInProgress = false;
throw;
}
}
void DOMParser::parse(const char* const systemId, const bool reuseValidator)
{
// Avoid multiple entrance
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
try
{
fParseInProgress = true;
fScanner->scanDocument(systemId, reuseValidator);
fParseInProgress = false;
}
catch(...)
{
fParseInProgress = false;
throw;
}
}
// ---------------------------------------------------------------------------
// DOMParser: Progressive parse methods
// ---------------------------------------------------------------------------
bool DOMParser::parseFirst( const XMLCh* const systemId
, XMLPScanToken& toFill
, const bool reuseValidator)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
return fScanner->scanFirst(systemId, toFill, reuseValidator);
}
bool DOMParser::parseFirst( const char* const systemId
, XMLPScanToken& toFill
, const bool reuseValidator)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
return fScanner->scanFirst(systemId, toFill, reuseValidator);
}
bool DOMParser::parseFirst( const InputSource& source
, XMLPScanToken& toFill
, const bool reuseValidator)
{
//
// Avoid multiple entrance. We cannot enter here while a regular parse
// is in progress.
//
if (fParseInProgress)
ThrowXML(IOException, XMLExcepts::Gen_ParseInProgress);
return fScanner->scanFirst(source, toFill, reuseValidator);
}
bool DOMParser::parseNext(XMLPScanToken& token)
{
return fScanner->scanNext(token);
}
void DOMParser::parseReset(XMLPScanToken& token)
{
// Reset the scanner, and then reset the parser
fScanner->scanReset(token);
reset();
}
// ---------------------------------------------------------------------------
// DOMParser: Implementation of the XMLErrorReporter interface
// ---------------------------------------------------------------------------
void DOMParser::error( const unsigned int code
, const XMLCh* const msgDomain
, const XMLErrorReporter::ErrTypes errType
, const XMLCh* const errorText
, const XMLCh* const systemId
, const XMLCh* const publicId
, const unsigned int lineNum
, const unsigned int colNum)
{
SAXParseException toThrow = SAXParseException
(
errorText
, publicId
, systemId
, lineNum
, colNum
);
//
// If there is an error handler registered, call it, otherwise ignore
// all but the fatal errors.
//
if (!fErrorHandler)
{
if (errType == XMLErrorReporter::ErrType_Fatal)
throw toThrow;
return;
}
if (errType == XMLErrorReporter::ErrType_Warning)
fErrorHandler->warning(toThrow);
else if (errType >= XMLErrorReporter::ErrType_Fatal)
fErrorHandler->fatalError(toThrow);
else
fErrorHandler->error(toThrow);
}
void DOMParser::resetErrors()
{
}
// ---------------------------------------------------------------------------
// DOMParser: Implementation of XMLEntityHandler interface
// ---------------------------------------------------------------------------
InputSource*
DOMParser::resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId)
{
//
// Just map it to the SAX entity resolver. If there is not one installed,
// return a null pointer to cause the default resolution.
//
if (fEntityResolver)
return fEntityResolver->resolveEntity(publicId, systemId);
return 0;
}
// ---------------------------------------------------------------------------
// DOMParser: Implementation of XMLDocumentHandler interface
// ---------------------------------------------------------------------------
void DOMParser::docCharacters( const XMLCh* const chars
, const unsigned int length
, const bool cdataSection)
{
// Ignore chars outside of content
if (!fWithinElement)
return;
if (cdataSection == true)
{
DOM_CDATASection node = fDocument.createCDATASection
(
DOMString(chars, length)
);
fCurrentParent.appendChild(node);
fCurrentNode = node;
}
else
{
if (fCurrentNode.getNodeType() == DOM_Node::TEXT_NODE)
{
DOM_Text node = (DOM_Text&)fCurrentNode;
node.appendData(DOMString(chars, length));
}
else
{
DOM_Text node = fDocument.createTextNode(DOMString(chars, length));
//If the node type is entityRef then set the readOnly flag to false before appending node
bool oldReadFlag;
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
oldReadFlag = fCurrentParent.fImpl->isReadOnly();
fCurrentParent.fImpl->isReadOnly(false);
}
fCurrentParent.appendChild(node);
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
fCurrentParent.fImpl->isReadOnly(oldReadFlag);
}
fCurrentNode = node;
}
}
}
void DOMParser::docComment(const XMLCh* const comment)
{
DOM_Comment dcom = fDocument.createComment(comment);
fCurrentParent.appendChild(dcom);
fCurrentNode = dcom;
}
void DOMParser::docPI( const XMLCh* const target
, const XMLCh* const data)
{
DOM_ProcessingInstruction pi = fDocument.createProcessingInstruction
(
target
, data
);
fCurrentParent.appendChild(pi);
fCurrentNode = pi;
}
void DOMParser::endEntityReference(const XMLEntityDecl& entDecl)
{
if (fCreateEntityReferenceNodes == true)
{
fCurrentParent = fNodeStack->pop();
fCurrentNode = fCurrentParent;
}
}
void DOMParser::endElement( const XMLElementDecl& elemDecl
, const unsigned int urlId
, const bool isRoot)
{
fCurrentNode = fCurrentParent;
fCurrentParent = fNodeStack->pop();
// If we've hit the end of content, clear the flag
if (fNodeStack->empty())
fWithinElement = false;
}
void DOMParser::ignorableWhitespace(const XMLCh* const chars
, const unsigned int length
, const bool cdataSection)
{
// Ignore chars before the root element
if (!fWithinElement || !fIncludeIgnorableWhitespace)
return;
if (fCurrentNode.getNodeType() == DOM_Node::TEXT_NODE)
{
DOM_Text node = (DOM_Text&)fCurrentNode;
node.appendData(DOMString(chars, length));
}
else
{
DOM_Text node = fDocument.createTextNode(DOMString(chars, length));
TextImpl *text = (TextImpl *) node.fImpl;
text -> setIgnorableWhitespace(true);
//If the node type is entityRef then set the readOnly flag to false before appending node
bool oldReadFlag;
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
oldReadFlag = fCurrentParent.fImpl->isReadOnly();
fCurrentParent.fImpl->isReadOnly(false);
}
fCurrentParent.appendChild(node);
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
fCurrentParent.fImpl->isReadOnly(oldReadFlag);
}
fCurrentNode = node;
}
}
void DOMParser::resetDocument()
{
//
// The reset methods are called before a new parse event occurs.
// Reset this parsers state to clear out anything that may be left
// from a previous use, in particular the DOM document itself.
//
this->reset();
}
void DOMParser::startDocument()
{
// Just set the document as the current parent and current node
fCurrentParent = fDocument;
fCurrentNode = fDocument;
}
void DOMParser::startElement(const XMLElementDecl& elemDecl
, const unsigned int urlId
, const XMLCh* const elemPrefix
, const RefVectorOf<XMLAttr>& attrList
, const unsigned int attrCount
, const bool isEmpty
, const bool isRoot)
{
DOM_Element elem;
DocumentImpl *docImpl = (DocumentImpl *)fDocument.fImpl;
if (fScanner -> getDoNamespaces()) { //DOM Level 2, doNamespaces on
unsigned int globalNSid = fValidator -> getGlobalNamespaceId();
XMLBuffer buf;
DOMString namespaceURI = 0;
if (urlId != globalNSid) { //TagName has a prefix
fValidator -> getURIText(urlId, buf); //get namespaceURI
namespaceURI = DOMString(buf.getRawBuffer());
}
elem = fDocument.createElementNS(namespaceURI, elemDecl.getFullName());
ElementImpl *elemImpl = (ElementImpl *) elem.fImpl;
for (unsigned int index = 0; index < attrCount; ++index) {
static const XMLCh XMLNS[] = {
chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull
};
const XMLAttr* oneAttrib = attrList.elementAt(index);
unsigned int attrURIId = oneAttrib -> getURIId();
namespaceURI = 0;
if (!XMLString::compareString(oneAttrib -> getName(), XMLNS)) //for xmlns=...
attrURIId = fValidator -> getXMLNSNamespaceId();
if (attrURIId != globalNSid) { //TagName has a prefix
fValidator -> getURIText(attrURIId, buf); //get namespaceURI
namespaceURI = DOMString(buf.getRawBuffer());
}
AttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
oneAttrib -> getValue());
// Attributes of type ID. If this is one, add it to the hashtable of IDs
// that is constructed for use by GetElementByID().
//
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (docImpl->fNodeIDMap == 0)
docImpl->fNodeIDMap = new NodeIDMap(500);
docImpl->fNodeIDMap->add(attr);
attr->isIdAttr(true);
}
attr->setSpecified(oneAttrib->getSpecified());
}
}
else { //DOM Level 1
elem = fDocument.createElement(elemDecl.getFullName());
ElementImpl *elemImpl = (ElementImpl *) elem.fImpl;
for (unsigned int index = 0; index < attrCount; ++index) {
const XMLAttr* oneAttrib = attrList.elementAt(index);
AttrImpl *attr = elemImpl->setAttribute(oneAttrib->getName(), oneAttrib->getValue());
attr->setSpecified(oneAttrib->getSpecified());
// Attributes of type ID. If this is one, add it to the hashtable of IDs
// that is constructed for use by GetElementByID().
//
if (oneAttrib->getType()==XMLAttDef::ID)
{
if (docImpl->fNodeIDMap == 0)
docImpl->fNodeIDMap = new NodeIDMap(500);
docImpl->fNodeIDMap->add(attr);
attr->isIdAttr(true);
}
}
}
//If the node type is entityRef then set the readOnly flag to false before appending node
bool oldReadFlag;
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
oldReadFlag = fCurrentParent.fImpl->isReadOnly();
fCurrentParent.fImpl->isReadOnly(false);
}
fCurrentParent.appendChild(elem);
if (fCurrentParent.getNodeType() == DOM_Node::ENTITY_REFERENCE_NODE) {
fCurrentParent.fImpl->isReadOnly(oldReadFlag);
}
fNodeStack->push(fCurrentParent);
fCurrentParent = elem;
fCurrentNode = elem;
fWithinElement = true;
// If an empty element, do end right now (no endElement() will be called)
if (isEmpty)
endElement(elemDecl, urlId, isRoot);
}
void DOMParser::startEntityReference(const XMLEntityDecl& entDecl)
{
if (fCreateEntityReferenceNodes == true)
{
DOMString entName(entDecl.getName());
DOM_EntityReference er = fDocument.createEntityReference(entName);
fCurrentParent.appendChild(er);
fNodeStack->push(fCurrentParent);
fCurrentParent = er;
fCurrentNode = er;
// this entityRef needs to be stored in Entity map too.
// We'd decide later whether the entity nodes should be created by a
// separated method in parser or not. For now just stick it in if
// the ref nodes are created
EntityImpl* entity = (EntityImpl*)fDocumentType->entities->getNamedItem(entName);
entity->setEntityRef((EntityReferenceImpl*)er.fImpl);
}
}
void DOMParser::XMLDecl(const XMLCh* const version
, const XMLCh* const encoding
, const XMLCh* const standalone
, const XMLCh* const actualEncStr)
{
//This is a non-standard extension to creating XMLDecl type nodes and attching to DOM Tree
// currently this flag it set to false unless user explicitly asks for it
// Needs to be revisited after W3C specs are laid out on this issue.
if (fToCreateXMLDeclTypeNode) {
DOMString ver(version);
DOMString enc(encoding);
DOMString std(standalone);
DOM_XMLDecl xmlDecl = fDocument.createXMLDecl(ver, enc, std);
fCurrentParent.appendChild(xmlDecl);
}
}
// ---------------------------------------------------------------------------
// DOMParser: Deprecated methods
// ---------------------------------------------------------------------------
bool DOMParser::getDoValidation() const
{
//
// We don't want to tie the public parser classes to the enum used
// by the scanner, so we use a separate one and map.
//
// DON'T mix the new and old methods!!
//
const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
if (scheme == XMLScanner::Val_Always)
return true;
return false;
}
void DOMParser::setDoValidation(const bool newState)
{
fScanner->setDoValidation
(
newState ? XMLScanner::Val_Always : XMLScanner::Val_Never
);
}
//doctypehandler interfaces
void DOMParser::attDef
(
const DTDElementDecl& elemDecl
, const DTDAttDef& attDef
, const bool ignoring
)
{
if(fOldDocTypeHandler)
{
fOldDocTypeHandler->attDef(elemDecl,attDef, ignoring );
}
if (fDocumentType->isIntSubsetReading())
{
DOMString attString;
if (elemDecl.hasAttDefs())
{
attString.appendData(chOpenAngle);
attString.appendData(chBang);
attString.appendData(XMLUni::fgAttListString);
attString.appendData(chSpace);
attString.appendData(elemDecl.getFullName());
attString.appendData(chSpace);
attString.appendData(attDef.getFullName());
// Get the type and display it
const XMLAttDef::AttTypes type = attDef.getType();
switch(type)
{
case XMLAttDef::CData :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgCDATAString);
break;
case XMLAttDef::ID :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgIDString);
break;
case XMLAttDef::IDRef :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgIDRefString);
break;
case XMLAttDef::IDRefs :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgIDRefsString);
break;
case XMLAttDef::Entity :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgEntityString);
break;
case XMLAttDef::Entities :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgEntitiesString);
break;
case XMLAttDef::NmToken :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgNmTokenString);
break;
case XMLAttDef::NmTokens :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgNmTokensString);
break;
case XMLAttDef::Notation :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgNotationString);
break;
case XMLAttDef::Enumeration :
attString.appendData(chSpace);
// attString.appendData(XMLUni::fgEnumerationString);
const XMLCh* enumString = attDef.getEnumeration();
int length = XMLString::stringLen(enumString);
if (length > 0) {
DOMString anotherEnumString;
anotherEnumString.appendData(chOpenParen );
for(int i=0; i<length; i++) {
if (enumString[i] == chSpace)
anotherEnumString.appendData(chPipe);
else
anotherEnumString.appendData(enumString[i]);
}
anotherEnumString.appendData(chCloseParen);
attString.appendData(anotherEnumString);
enumString = attDef.getValue();
if ( enumString != 0) {
attString.appendData(chSpace);
attString.appendData(chDoubleQuote);
attString.appendData(XMLString::transcode(attDef.getValue()));
attString.appendData(chDoubleQuote);
}
}
break;
}
//get te default types of the attlist
const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
switch(def)
{
case XMLAttDef::Required :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgRequiredString);
break;
case XMLAttDef::Implied :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgImpliedString);
break;
case XMLAttDef::Fixed :
attString.appendData(chSpace);
attString.appendData(XMLUni::fgFixedString);
break;
}
attString.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(attString);
}
}
}
void DOMParser::doctypeComment
(
const XMLCh* const comment
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypeComment(comment);
}
if (fDocumentType->isIntSubsetReading())
{
if (comment != 0)
{
DOMString comString;
comString.appendData(XMLUni::fgCommentString);
comString.appendData(chSpace);
comString.appendData(comment);
comString.appendData(chSpace);
comString.appendData(chDash);
comString.appendData(chDash);
comString.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(comString);
}
}
}
void DOMParser::doctypeDecl
(
const DTDElementDecl& elemDecl
, const XMLCh* const publicId
, const XMLCh* const systemId
, const bool hasIntSubset
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypeDecl(elemDecl, publicId, systemId, hasIntSubset);
}
DOM_DocumentType dt;
dt = fDocument.getImplementation().createDocumentType(elemDecl.getFullName(), publicId, systemId);
fDocumentType = (DocumentTypeImpl*)dt.fImpl;
((DocumentImpl*)fDocument.fImpl)->setDocumentType(fDocumentType);
populateDocumentType(); // Add the entities and notations to this DocType.
}
void DOMParser::doctypePI
(
const XMLCh* const target
, const XMLCh* const data
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypePI(target, data);
}
if (fDocumentType->isIntSubsetReading())
{
//add these chars to internalSubset variable
DOMString pi;
pi.appendData(chOpenAngle);
pi.appendData(chQuestion);
pi.appendData(target);
pi.appendData(chSpace);
pi.appendData(data);
pi.appendData(chQuestion);
pi.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(pi);
}
}
void DOMParser::doctypeWhitespace
(
const XMLCh* const chars
, const unsigned int length
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->doctypeWhitespace(chars, length);
}
if (fDocumentType->isIntSubsetReading())
fDocumentType->internalSubset.appendData(chars);
}
void DOMParser::elementDecl
(
const DTDElementDecl& decl
, const bool isIgnored
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->elementDecl(decl, isIgnored);
}
if (fDocumentType->isIntSubsetReading())
{
DOMString elemDecl;
elemDecl.appendData(chOpenAngle);
elemDecl.appendData(chBang);
elemDecl.appendData(XMLUni::fgElemString);
elemDecl.appendData(chSpace);
elemDecl.appendData(decl.getFullName());
//get the ContentSpec information
const XMLCh* contentModel = decl.getFormattedContentModel(*fValidator);
if (contentModel != 0) {
elemDecl.appendData(chSpace);
elemDecl.appendData(contentModel);
}
elemDecl.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(elemDecl);
}
}
void DOMParser::endAttList
(
const DTDElementDecl& elemDecl
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->endAttList(elemDecl);
}
// this section sets up default attributes.
// default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
// default attribute data attached to the document is used to conform to the
// DOM spec regarding creating element nodes & removing attributes with default values
// see DocumentTypeImpl
if (elemDecl.hasAttDefs())
{
XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
XMLAttDef* attr = 0;
AttrImpl* insertAttr = 0;
DOM_Element dom_elem = fDocument.createElement(elemDecl.getFullName());
ElementImpl* elem = (ElementImpl*)(dom_elem.fImpl);
static const XMLCh XMLNS[] = {chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
while (defAttrs->hasMoreElements())
{
attr = &defAttrs->nextElement();
if (attr->getValue() != null)
{
if (fScanner->getDoNamespaces())
{
// Namespaces is turned on...
unsigned int attrURIId = attr->getId();
XMLBuffer buf;
DOMString namespaceURI = 0;
if (!XMLString::compareString(attr->getFullName(), XMLNS)) //for xmlns=...
attrURIId = fValidator->getXMLNSNamespaceId();
if (attrURIId != fValidator->getGlobalNamespaceId()) { //TagName has a prefix
fValidator->getURIText(attrURIId, buf); //get namespaceURI
namespaceURI = DOMString(buf.getRawBuffer());
}
insertAttr = elem->setAttributeNS(namespaceURI, attr->getFullName(), attr->getValue());
insertAttr->setSpecified(false);
}
else
{
// Namespaces is turned off...
insertAttr = new AttrImpl((DocumentImpl*)fDocument.fImpl, attr->getFullName());
insertAttr->setValue(attr->getValue());
elem->setAttributeNode(insertAttr);
insertAttr->setSpecified(false);
}
}
}
fDocumentType->getElements()->setNamedItem(elem);
}
}
void DOMParser::endIntSubset()
{
fDocumentType->intSubsetReading = false;
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->endIntSubset();
}
}
void DOMParser::endExtSubset()
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->endExtSubset();
}
}
void DOMParser::entityDecl
(
const DTDEntityDecl& entityDecl
, const bool isPEDecl
, const bool isIgnored
)
{
EntityImpl* entity = ((DocumentImpl*)fDocument.fImpl)->createEntity(entityDecl.getName());
entity->setPublicId(entityDecl.getPublicId());
entity->setSystemId(entityDecl.getSystemId());
entity->setNotationName(entityDecl.getNotationName());
EntityImpl *previousDef = (EntityImpl *)
fDocumentType->entities->setNamedItem( entity );
//
// If this new entity node is replacing an entity node that was already
// in the entities named node map (happens if documents redefine the
// predefined entited such as lt), we need to delete the original
// entitiy node, assuming no-one else was referencing it.
//
if (previousDef != 0 && previousDef->nodeRefCount == 0)
NodeImpl::deleteIf(previousDef);
if (fDocumentType->isIntSubsetReading())
{
//add thes chars to internalSubset variable
DOMString entityName;
entityName.appendData(chOpenAngle);
entityName.appendData(chBang);
entityName.appendData(XMLUni::fgEntityString);
entityName.appendData(chSpace);
entityName.appendData(entityDecl.getName());
DOMString id = entity->getPublicId();
if (id != 0) {
entityName.appendData(chSpace);
entityName.appendData(XMLUni::fgPubIDString);
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
id = entity->getSystemId();
if (id != 0) {
entityName.appendData(chSpace);
entityName.appendData(XMLUni::fgSysIDString);
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
id = entity->getNotationName();
if (id != 0) {
entityName.appendData(chSpace);
entityName.appendData(XMLUni::fgNDATAString);
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
id = entityDecl.getValue();
if (id !=0) {
entityName.appendData(chSpace);
entityName.appendData(chDoubleQuote);
entityName.appendData(id);
entityName.appendData(chDoubleQuote);
}
entityName.appendData(chCloseAngle);
fDocumentType->internalSubset.appendData(entityName);
}
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->entityDecl(entityDecl, isPEDecl, isIgnored);
}
}
void DOMParser::resetDocType()
{
fDocumentType = null;
}
void DOMParser::notationDecl
(
const XMLNotationDecl& notDecl
, const bool isIgnored
)
{
NotationImpl* notation = ((DocumentImpl*)fDocument.fImpl)->createNotation(notDecl.getName());
notation->setPublicId(notDecl.getPublicId());
notation->setPublicId(notDecl.getPublicId());
fDocumentType->notations->setNamedItem( notation );
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->notationDecl(notDecl, isIgnored);
}
}
void DOMParser::startAttList
(
const DTDElementDecl& elemDecl
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->startAttList(elemDecl);
}
}
void DOMParser::startIntSubset()
{
fDocumentType->intSubsetReading = true;
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->startIntSubset();
}
}
void DOMParser::startExtSubset()
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->startExtSubset();
}
}
void DOMParser::TextDecl
(
const XMLCh* const versionStr
, const XMLCh* const encodingStr
)
{
if (fOldDocTypeHandler)
{
fOldDocTypeHandler->TextDecl(versionStr, encodingStr);
}
}
// to populate the entities in the documentType
void DOMParser::populateDocumentType()
{
if (fDocumentType == null)
return;
NameIdPoolEnumerator<DTDEntityDecl> entityPoolEnum = ((DTDValidator*)fValidator)->getEntityEnumerator();
while(entityPoolEnum.hasMoreElements()) {
DTDEntityDecl* entityDecl = &entityPoolEnum.nextElement();
EntityImpl* entity = ((DocumentImpl*)fDocument.fImpl)->createEntity(entityDecl->getName());
entity->setPublicId(entityDecl->getPublicId());
entity->setSystemId(entityDecl->getSystemId());
entity->setNotationName(entityDecl->getNotationName());
fDocumentType->entities->setNamedItem( entity );
}
NameIdPoolEnumerator<XMLNotationDecl> notationPoolEnum = ((DTDValidator*)fValidator)->getNotationEnumerator();
while(notationPoolEnum.hasMoreElements()) {
XMLNotationDecl* notationDecl = ¬ationPoolEnum.nextElement();
NotationImpl* notation = ((DocumentImpl*)fDocument.fImpl)->createNotation(notationDecl->getName());
notation->setPublicId(notationDecl->getPublicId());
notation->setPublicId(notationDecl->getPublicId());
fDocumentType->notations->setNamedItem( notation );
}
}
|
/*
WireS - Slave only I2C library for ATtiny1634 and ATtiny841
Copyright (c) 2015 by Hisashi Ito (info at mewpro.cc)
------------------------------------------------------------------------------------------------------
Some code segments derived from:
i2c_t3 - I2C library for Teensy 3.0/3.1/LC
- (v8) Modified 02Apr15 by Brian (nox771 at gmail.com)
and
TwoWire.cpp - TWI/I2C library for Wiring & Arduino
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
------------------------------------------------------------------------------------------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
// This library should work with the following AVR microcontrollers
// having an I2C compatible, two-wire slave only interface.
#if defined(__AVR_ATtiny1634__) || defined(__AVR_ATtiny841__) || defined(__AVR_ATtiny441__) || defined(__AVR_ATtiny828__) || defined(__AVR_ATtiny40__) || defined(__AVR_ATtiny20__)
// Disclaimer: The author only confirmed the library to work with ATtiny1634 and ATtiny841.
#include <avr/io.h>
#include "WireS.h"
//#define TWI_HIGH_NOISE_MODE _BV(TWHNM) // only for ATtiny441/841 or ATtiny828
#define TWI_HIGH_NOISE_MODE 0
#ifndef TWAE // avr/iotn1634.h doesn't define
#define TWAE 0
#endif
// use MSB of i2c->Addr as a flag to indicate 10-bit slave address is on receiving
#define SET_TENBIT do { i2c->Addr |= 0x8000; } while(0)
#define CLEAR_TENBIT do { i2c->Addr &= 0x7FFF; } while(0)
#define IS_TENBIT (i2c->Addr & 0x8000)
struct i2cStruct i2c_tinyS::i2cData;
// ------------------------------------------------------------------------------------------------------
// Constructor/Destructor
//
i2c_tinyS::i2c_tinyS()
{
i2c = &i2cData;
}
i2c_tinyS::~i2c_tinyS()
{
}
// ------------------------------------------------------------------------------------------------------
// Initialize I2C - initializes I2C as two address or address range Slave
// return: none
// parameters:
// address = 7bit address for specifying 1st Slave address
// mask = 8bit integer;
// if bit[0]==1 then bit[7:1] 2nd Slave address
// if bit[0]==0 then bit[7:1] mask bits for address
//
void i2c_tinyS::begin_(struct i2cStruct* i2c, uint8_t address, uint8_t mask)
{
I2C_INTR_FLAG_INIT; // init I2C interrupt flag if used
TWSA = (address << 1);
TWSAM = mask; // if mask == 0 then only one address
i2c->startCount = -1;
TWSCRA = (_BV(TWSHE) | _BV(TWDIE) | _BV(TWASIE) | _BV(TWEN) | _BV(TWSIE));
}
// ------------------------------------------------------------------------------------------------------
// Write - write data to Tx buffer
// return: 1=success, 0=fail
// parameters:
// data = data byte
//
size_t i2c_tinyS::write(uint8_t data)
{
if(i2c->txBufferLength < I2C_BUFFER_LENGTH)
{
i2c->Buffer[i2c->txBufferLength++] = data;
return 1;
}
return 0;
}
// ------------------------------------------------------------------------------------------------------
// Write Array - write length number of bytes from data array to Tx buffer
// parameters:
// data = pointer to uint8_t array of data
// length = number of bytes to write
//
size_t i2c_tinyS::write(const uint8_t* data, size_t quantity)
{
if(i2c->txBufferLength < I2C_BUFFER_LENGTH)
{
size_t avail = I2C_BUFFER_LENGTH - i2c->txBufferLength;
uint8_t* dest = i2c->Buffer + i2c->txBufferLength;
if(quantity > avail)
{
quantity = avail; // truncate to space avail if needed
}
for(size_t count=quantity; count; count--)
*dest++ = *data++;
i2c->txBufferLength += quantity;
}
}
// ------------------------------------------------------------------------------------------------------
// Read - returns next data byte (signed int) from Rx buffer
// return: data, -1 if buffer empty
//
int i2c_tinyS::read_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return -1;
return i2c->Buffer[i2c->rxBufferIndex++];
}
// ------------------------------------------------------------------------------------------------------
// Peek - returns next data byte (signed int) from Rx buffer without removing it from Rx buffer
// return: data, -1 if buffer empty
//
int i2c_tinyS::peek_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return -1;
return i2c->Buffer[i2c->rxBufferIndex];
}
// ------------------------------------------------------------------------------------------------------
// Read Byte - returns next data byte (uint8_t) from Rx buffer
// return: data, 0 if buffer empty
//
uint8_t i2c_tinyS::readByte_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return 0;
return i2c->Buffer[i2c->rxBufferIndex++];
}
// ------------------------------------------------------------------------------------------------------
// Peek Byte - returns next data byte (uint8_t) from Rx buffer without removing it from Rx buffer
// return: data, 0 if buffer empty
//
uint8_t i2c_tinyS::peekByte_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return 0;
return i2c->Buffer[i2c->rxBufferIndex];
}
// ======================================================================================================
// ------------------------------------------------------------------------------------------------------
// I2C Interrupt Service Routine
// ------------------------------------------------------------------------------------------------------
// ======================================================================================================
void i2c_isr_handler()
{
struct i2cStruct *i2c = &(i2c_tinyS::i2cData);
byte status = TWSSRA;
if ((status & (_BV(TWC) | _BV(TWBE)))) {
// Bus error or transmit collision
i2c->startCount = -1;
CLEAR_TENBIT;
TWSSRA |= (_BV(TWASIF) | _BV(TWDIF) | _BV(TWBE)); // Release hold
return;
}
if ((status & _BV(TWASIF)) || IS_TENBIT) {
if ((status & _BV(TWAS))) {
// A valid address has been received
if (IS_TENBIT) {
i2c->Addr = (((i2c->Addr & B110) << 7) | TWSD);
// CLEAR_TENBIT;
} else {
i2c->Addr = TWSD;
i2c->startCount++;
if ((i2c->Addr & B11111001) == B11110000) {
SET_TENBIT;
TWSCRB = (B0011 | TWI_HIGH_NOISE_MODE); // Send ACK
return;
}
}
if (i2c->user_onAddrReceive != (void *)NULL) {
i2c->rxBufferIndex = 0;
if (!i2c->user_onAddrReceive(i2c->Addr, i2c->startCount)) {
TWSCRB = (B0111 | TWI_HIGH_NOISE_MODE); // Send NACK
return;
}
}
if ((status & _BV(TWDIR))) {
// A master read operation is in progress
i2c->txBufferLength = 0;
if (i2c->user_onRequest != (void *)NULL) {
i2c->user_onRequest(); // load Tx buffer with data
}
i2c->txBufferIndex = 0;
} else {
// A master write operation is in progress
i2c->rxBufferLength = 0;
}
} else {
// Stop condition is detected
if ((status & _BV(TWDIR))) {
if (i2c->user_onStop != (void *)NULL) {
i2c->user_onStop();
}
} else {
if (i2c->user_onReceive != (void *)NULL) {
i2c->rxBufferIndex = 0;
i2c->user_onReceive(i2c->rxBufferLength);
}
}
i2c->startCount = -1;
CLEAR_TENBIT;
TWSSRA = _BV(TWASIF); // clear interrupt
return;
}
} else if ((status & _BV(TWDIF))) {
if ((status & _BV(TWDIR))) {
// Send a data byte to master
if (i2c->txBufferIndex < i2c->txBufferLength) {
TWSD = i2c->Buffer[i2c->txBufferIndex++];
} else {
// buffer overrun
TWSCRB = (B0010 | TWI_HIGH_NOISE_MODE); // Wait for any START condition
return;
}
} else {
// A data byte has been received
if (i2c->rxBufferLength < I2C_BUFFER_LENGTH) {
i2c->Buffer[i2c->rxBufferLength++] = TWSD;
} else {
// buffer overrun
TWSCRB = (B0110 | TWI_HIGH_NOISE_MODE); // Send NACK and wait for any START condition
return;
}
}
}
TWSCRB = (B0011 | TWI_HIGH_NOISE_MODE);
}
ISR(TWI_SLAVE_vect)
{
I2C_INTR_FLAG_ON;
i2c_isr_handler();
I2C_INTR_FLAG_OFF;
}
// ------------------------------------------------------------------------------------------------------
// Instantiate
//
i2c_tinyS Wire = i2c_tinyS();
#endif
ATtiny828 support
/*
WireS - Slave only I2C library for ATtiny1634, ATtiny441/841, and ATtiny828.
Copyright (c) 2015 by Hisashi Ito (info at mewpro.cc)
------------------------------------------------------------------------------------------------------
Some code segments derived from:
i2c_t3 - I2C library for Teensy 3.0/3.1/LC
- (v8) Modified 02Apr15 by Brian (nox771 at gmail.com)
and
TwoWire.cpp - TWI/I2C library for Wiring & Arduino
Copyright (c) 2006 Nicholas Zambetti. All right reserved.
Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
------------------------------------------------------------------------------------------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
// This library should work with the following AVR microcontrollers
// having an I2C compatible, two-wire slave only interface.
#if defined(__AVR_ATtiny1634__) || defined(__AVR_ATtiny841__) || defined(__AVR_ATtiny441__) || defined(__AVR_ATtiny828__) || defined(__AVR_ATtiny40__) || defined(__AVR_ATtiny20__)
// Disclaimer: The author only confirmed the library to work with ATtiny1634, ATtiny841, and ATtiny828.
#include <avr/io.h>
#include "WireS.h"
//#define TWI_HIGH_NOISE_MODE _BV(TWHNM) // only for ATtiny441/841 or ATtiny828
#define TWI_HIGH_NOISE_MODE 0
#ifndef TWAE // avr/iotn1634.h doesn't define
#define TWAE 0
#endif
// use MSB of i2c->Addr as a flag to indicate 10-bit slave address is on receiving
#define SET_TENBIT do { i2c->Addr |= 0x8000; } while(0)
#define CLEAR_TENBIT do { i2c->Addr &= 0x7FFF; } while(0)
#define IS_TENBIT (i2c->Addr & 0x8000)
struct i2cStruct i2c_tinyS::i2cData;
// ------------------------------------------------------------------------------------------------------
// Constructor/Destructor
//
i2c_tinyS::i2c_tinyS()
{
i2c = &i2cData;
}
i2c_tinyS::~i2c_tinyS()
{
}
// ------------------------------------------------------------------------------------------------------
// Initialize I2C - initializes I2C as two address or address range Slave
// return: none
// parameters:
// address = 7bit address for specifying 1st Slave address
// mask = 8bit integer;
// if bit[0]==1 then bit[7:1] 2nd Slave address
// if bit[0]==0 then bit[7:1] mask bits for address
//
void i2c_tinyS::begin_(struct i2cStruct* i2c, uint8_t address, uint8_t mask)
{
I2C_INTR_FLAG_INIT; // init I2C interrupt flag if used
TWSA = (address << 1);
TWSAM = mask; // if mask == 0 then only one address
i2c->startCount = -1;
TWSCRA = (_BV(TWSHE) | _BV(TWDIE) | _BV(TWASIE) | _BV(TWEN) | _BV(TWSIE));
}
// ------------------------------------------------------------------------------------------------------
// Write - write data to Tx buffer
// return: 1=success, 0=fail
// parameters:
// data = data byte
//
size_t i2c_tinyS::write(uint8_t data)
{
if(i2c->txBufferLength < I2C_BUFFER_LENGTH)
{
i2c->Buffer[i2c->txBufferLength++] = data;
return 1;
}
return 0;
}
// ------------------------------------------------------------------------------------------------------
// Write Array - write length number of bytes from data array to Tx buffer
// parameters:
// data = pointer to uint8_t array of data
// length = number of bytes to write
//
size_t i2c_tinyS::write(const uint8_t* data, size_t quantity)
{
if(i2c->txBufferLength < I2C_BUFFER_LENGTH)
{
size_t avail = I2C_BUFFER_LENGTH - i2c->txBufferLength;
uint8_t* dest = i2c->Buffer + i2c->txBufferLength;
if(quantity > avail)
{
quantity = avail; // truncate to space avail if needed
}
for(size_t count=quantity; count; count--)
*dest++ = *data++;
i2c->txBufferLength += quantity;
}
}
// ------------------------------------------------------------------------------------------------------
// Read - returns next data byte (signed int) from Rx buffer
// return: data, -1 if buffer empty
//
int i2c_tinyS::read_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return -1;
return i2c->Buffer[i2c->rxBufferIndex++];
}
// ------------------------------------------------------------------------------------------------------
// Peek - returns next data byte (signed int) from Rx buffer without removing it from Rx buffer
// return: data, -1 if buffer empty
//
int i2c_tinyS::peek_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return -1;
return i2c->Buffer[i2c->rxBufferIndex];
}
// ------------------------------------------------------------------------------------------------------
// Read Byte - returns next data byte (uint8_t) from Rx buffer
// return: data, 0 if buffer empty
//
uint8_t i2c_tinyS::readByte_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return 0;
return i2c->Buffer[i2c->rxBufferIndex++];
}
// ------------------------------------------------------------------------------------------------------
// Peek Byte - returns next data byte (uint8_t) from Rx buffer without removing it from Rx buffer
// return: data, 0 if buffer empty
//
uint8_t i2c_tinyS::peekByte_(struct i2cStruct* i2c)
{
if(i2c->rxBufferIndex >= i2c->rxBufferLength) return 0;
return i2c->Buffer[i2c->rxBufferIndex];
}
// ======================================================================================================
// ------------------------------------------------------------------------------------------------------
// I2C Interrupt Service Routine
// ------------------------------------------------------------------------------------------------------
// ======================================================================================================
void i2c_isr_handler()
{
struct i2cStruct *i2c = &(i2c_tinyS::i2cData);
byte status = TWSSRA;
if ((status & (_BV(TWC) | _BV(TWBE)))) {
// Bus error or transmit collision
i2c->startCount = -1;
CLEAR_TENBIT;
TWSSRA |= (_BV(TWASIF) | _BV(TWDIF) | _BV(TWBE)); // Release hold
return;
}
if ((status & _BV(TWASIF)) || IS_TENBIT) {
if ((status & _BV(TWAS))) {
// A valid address has been received
if (IS_TENBIT) {
i2c->Addr = (((i2c->Addr & B110) << 7) | TWSD);
// CLEAR_TENBIT;
} else {
i2c->Addr = TWSD;
i2c->startCount++;
if ((i2c->Addr & B11111001) == B11110000) {
SET_TENBIT;
TWSCRB = (B0011 | TWI_HIGH_NOISE_MODE); // Send ACK
return;
}
}
if (i2c->user_onAddrReceive != (void *)NULL) {
i2c->rxBufferIndex = 0;
if (!i2c->user_onAddrReceive(i2c->Addr, i2c->startCount)) {
TWSCRB = (B0111 | TWI_HIGH_NOISE_MODE); // Send NACK
return;
}
}
if ((status & _BV(TWDIR))) {
// A master read operation is in progress
i2c->txBufferLength = 0;
if (i2c->user_onRequest != (void *)NULL) {
i2c->user_onRequest(); // load Tx buffer with data
}
i2c->txBufferIndex = 0;
} else {
// A master write operation is in progress
i2c->rxBufferLength = 0;
}
} else {
// Stop condition is detected
if ((status & _BV(TWDIR))) {
if (i2c->user_onStop != (void *)NULL) {
i2c->user_onStop();
}
} else {
if (i2c->user_onReceive != (void *)NULL) {
i2c->rxBufferIndex = 0;
i2c->user_onReceive(i2c->rxBufferLength);
}
}
i2c->startCount = -1;
CLEAR_TENBIT;
TWSSRA = _BV(TWASIF); // clear interrupt
return;
}
} else if ((status & _BV(TWDIF))) {
if ((status & _BV(TWDIR))) {
// Send a data byte to master
if (i2c->txBufferIndex < i2c->txBufferLength) {
TWSD = i2c->Buffer[i2c->txBufferIndex++];
} else {
// buffer overrun
TWSCRB = (B0010 | TWI_HIGH_NOISE_MODE); // Wait for any START condition
return;
}
} else {
// A data byte has been received
if (i2c->rxBufferLength < I2C_BUFFER_LENGTH) {
i2c->Buffer[i2c->rxBufferLength++] = TWSD;
} else {
// buffer overrun
TWSCRB = (B0110 | TWI_HIGH_NOISE_MODE); // Send NACK and wait for any START condition
return;
}
}
}
TWSCRB = (B0011 | TWI_HIGH_NOISE_MODE);
}
ISR(TWI_SLAVE_vect)
{
I2C_INTR_FLAG_ON;
i2c_isr_handler();
I2C_INTR_FLAG_OFF;
}
// ------------------------------------------------------------------------------------------------------
// Instantiate
//
i2c_tinyS Wire = i2c_tinyS();
#endif
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include "orcusinterface.hxx"
#include "document.hxx"
#include "formulacell.hxx"
#include "rangenam.hxx"
#include "tokenarray.hxx"
#include "globalnames.hxx"
#include "docoptio.hxx"
#include "globstr.hrc"
#include "compiler.hxx"
#include "formula/token.hxx"
#include "tools/datetime.hxx"
#include <com/sun/star/task/XStatusIndicator.hpp>
using namespace com::sun::star;
namespace os = orcus::spreadsheet;
ScOrcusGlobalSettings::ScOrcusGlobalSettings(ScDocumentImport& rDoc) : mrDoc(rDoc) {}
void ScOrcusGlobalSettings::set_origin_date(int year, int month, int day)
{
mrDoc.setOriginDate(year, month, day);
}
ScOrcusFactory::StringCellCache::StringCellCache(const ScAddress& rPos, size_t nIndex) :
maPos(rPos), mnIndex(nIndex) {}
ScOrcusFactory::ScOrcusFactory(ScDocument& rDoc) :
maDoc(rDoc),
maGlobalSettings(maDoc),
maSharedStrings(*this),
mnProgress(0) {}
orcus::spreadsheet::iface::import_sheet* ScOrcusFactory::append_sheet(const char* sheet_name, size_t sheet_name_length)
{
OUString aTabName(sheet_name, sheet_name_length, RTL_TEXTENCODING_UTF8);
if (!maDoc.appendSheet(aTabName))
return NULL;
SCTAB nTab = maDoc.getSheetCount() - 1;
maSheets.push_back(new ScOrcusSheet(maDoc, nTab, *this));
return &maSheets.back();
}
class FindSheetByIndex : std::unary_function<ScOrcusSheet, bool>
{
SCTAB mnTab;
public:
FindSheetByIndex(SCTAB nTab) : mnTab(nTab) {}
bool operator() (const ScOrcusSheet& rSheet) const
{
return rSheet.getIndex() == mnTab;
}
};
orcus::spreadsheet::iface::import_sheet* ScOrcusFactory::get_sheet(const char* sheet_name, size_t sheet_name_length)
{
OUString aTabName(sheet_name, sheet_name_length, RTL_TEXTENCODING_UTF8);
SCTAB nTab = maDoc.getSheetIndex(aTabName);
if (nTab < 0)
// Sheet by that name not found.
return NULL;
// See if we already have an orcus sheet instance by that index.
boost::ptr_vector<ScOrcusSheet>::iterator it =
std::find_if(maSheets.begin(), maSheets.end(), FindSheetByIndex(nTab));
if (it != maSheets.end())
// We already have one. Return it.
return &(*it);
// Create a new orcus sheet instance for this.
maSheets.push_back(new ScOrcusSheet(maDoc, nTab, *this));
return &maSheets.back();
}
orcus::spreadsheet::iface::import_sheet* ScOrcusFactory::get_sheet(orcus::spreadsheet::sheet_t sheet_index)
{
SCTAB nTab = static_cast<SCTAB>(sheet_index);
// See if we already have an orcus sheet instance by that index.
boost::ptr_vector<ScOrcusSheet>::iterator it =
std::find_if(maSheets.begin(), maSheets.end(), FindSheetByIndex(nTab));
if (it != maSheets.end())
// We already have one. Return it.
return &(*it);
// Create a new orcus sheet instance for this.
maSheets.push_back(new ScOrcusSheet(maDoc, nTab, *this));
return &maSheets.back();
}
orcus::spreadsheet::iface::import_global_settings* ScOrcusFactory::get_global_settings()
{
return &maGlobalSettings;
}
orcus::spreadsheet::iface::import_shared_strings* ScOrcusFactory::get_shared_strings()
{
return &maSharedStrings;
}
orcus::spreadsheet::iface::import_styles* ScOrcusFactory::get_styles()
{
return &maStyles;
}
void ScOrcusFactory::finalize()
{
int nCellCount = 0;
StringCellCaches::const_iterator it = maStringCells.begin(), itEnd = maStringCells.end();
for (; it != itEnd; ++it)
{
if (it->mnIndex >= maStrings.size())
// String index out-of-bound! Something is up.
continue;
maDoc.setStringCell(it->maPos, maStrings[it->mnIndex]);
++nCellCount;
if (nCellCount == 100000)
{
incrementProgress();
nCellCount = 0;
}
}
if (mxStatusIndicator.is())
mxStatusIndicator->end();
maDoc.finalize();
}
size_t ScOrcusFactory::appendString(const OUString& rStr)
{
size_t nPos = maStrings.size();
maStrings.push_back(rStr);
maStringHash.insert(StringHashType::value_type(rStr, nPos));
return nPos;
}
size_t ScOrcusFactory::addString(const OUString& rStr)
{
// Add only if the string is not yet present in the string pool.
StringHashType::iterator it = maStringHash.find(rStr);
if (it != maStringHash.end())
return it->second;
return appendString(rStr);
}
void ScOrcusFactory::pushStringCell(const ScAddress& rPos, size_t nStrIndex)
{
maStringCells.push_back(StringCellCache(rPos, nStrIndex));
}
void ScOrcusFactory::incrementProgress()
{
if (!mxStatusIndicator.is())
// Status indicator object not set.
return;
// For now, we'll hard-code the progress range to be 100, and stops at 99
// in all cases.
if (!mnProgress)
mxStatusIndicator->start(ScGlobal::GetRscString(STR_LOAD_DOC), 100);
if (mnProgress == 99)
return;
++mnProgress;
mxStatusIndicator->setValue(mnProgress);
}
void ScOrcusFactory::setStatusIndicator(const uno::Reference<task::XStatusIndicator>& rIndicator)
{
mxStatusIndicator = rIndicator;
}
ScOrcusSheet::ScOrcusSheet(ScDocumentImport& rDoc, SCTAB nTab, ScOrcusFactory& rFactory) :
mrDoc(rDoc), mnTab(nTab), mrFactory(rFactory), mnCellCount(0) {}
void ScOrcusSheet::cellInserted()
{
++mnCellCount;
if (mnCellCount == 100000)
{
mrFactory.incrementProgress();
mnCellCount = 0;
}
}
void ScOrcusSheet::set_auto(os::row_t row, os::col_t col, const char* p, size_t n)
{
OUString aVal(p, n, RTL_TEXTENCODING_UTF8);
mrDoc.setAutoInput(ScAddress(col, row, mnTab), aVal);
cellInserted();
}
void ScOrcusSheet::set_string(os::row_t row, os::col_t col, size_t sindex)
{
// We need to defer string cells since the shared string pool is not yet
// populated at the time this method is called. Orcus imports string
// table after the cells get imported. We won't need to do this once we
// implement true shared strings in Calc core.
mrFactory.pushStringCell(ScAddress(col, row, mnTab), sindex);
cellInserted();
}
void ScOrcusSheet::set_value(os::row_t row, os::col_t col, double value)
{
mrDoc.setNumericCell(ScAddress(col, row, mnTab), value);
cellInserted();
}
void ScOrcusSheet::set_bool(os::row_t row, os::col_t col, bool value)
{
mrDoc.setNumericCell(ScAddress(col, row, mnTab), value ? 1.0 : 0.0);
cellInserted();
}
void ScOrcusSheet::set_date_time(
os::row_t row, os::col_t col, int year, int month, int day, int hour, int minute, double second)
{
SvNumberFormatter* pFormatter = mrDoc.getDoc().GetFormatTable();
Date aDate(day, month, year);
sal_uInt32 nSec = floor(second);
sal_uInt32 nNanoSec = (second - nSec) * ::Time::nanoSecPerSec;
Time aTime(hour, minute, nSec, nNanoSec);
Date aNullDate(*pFormatter->GetNullDate());
long nDateDiff = aDate - aNullDate;
double fTime =
static_cast<double>(aTime.GetNanoSec()) / ::Time::nanoSecPerSec +
aTime.GetSec() +
aTime.GetMin() * ::Time::secondPerMinute +
aTime.GetHour() * ::Time::secondPerHour;
fTime /= DATE_TIME_FACTOR;
mrDoc.setNumericCell(ScAddress(col, row, mnTab), nDateDiff + fTime);
cellInserted();
}
void ScOrcusSheet::set_format(os::row_t /*row*/, os::col_t /*col*/, size_t /*xf_index*/)
{
}
namespace {
formula::FormulaGrammar::Grammar getCalcGrammarFromOrcus( os::formula_grammar_t grammar )
{
formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_ODFF;
switch(grammar)
{
case orcus::spreadsheet::ods:
eGrammar = formula::FormulaGrammar::GRAM_ODFF;
break;
case orcus::spreadsheet::xlsx_2007:
case orcus::spreadsheet::xlsx_2010:
eGrammar = formula::FormulaGrammar::GRAM_OOXML;
break;
case orcus::spreadsheet::gnumeric:
eGrammar = formula::FormulaGrammar::GRAM_ENGLISH_XL_A1;
break;
}
return eGrammar;
}
}
void ScOrcusSheet::set_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar, const char* p, size_t n)
{
OUString aFormula(p, n, RTL_TEXTENCODING_UTF8);
formula::FormulaGrammar::Grammar eGrammar = getCalcGrammarFromOrcus( grammar );
mrDoc.setFormulaCell(ScAddress(col,row,mnTab), aFormula, eGrammar);
cellInserted();
}
void ScOrcusSheet::set_formula_result(os::row_t row, os::col_t col, const char* p, size_t n)
{
ScFormulaCell* pCell = mrDoc.getDoc().GetFormulaCell(ScAddress(col, row, mnTab));
if (!pCell)
{
SAL_WARN("sc", "trying to set formula result for non formula \
cell! Col: " << col << ";Row: " << row << ";Tab: " << mnTab);
return;
}
OUString aResult( p, n, RTL_TEXTENCODING_UTF8);
pCell->SetHybridString(aResult);
}
void ScOrcusSheet::set_shared_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar, size_t sindex,
const char* p_formula, size_t n_formula)
{
ScAddress aPos(col, row, mnTab);
OUString aFormula(p_formula, n_formula, RTL_TEXTENCODING_UTF8);
formula::FormulaGrammar::Grammar eGram = getCalcGrammarFromOrcus(grammar);
// Compile the formula expression into tokens.
ScCompiler aComp(&mrDoc.getDoc(), aPos);
aComp.SetGrammar(eGram);
ScTokenArray* pArray = aComp.CompileString(aFormula);
if (!pArray)
// Tokenization failed.
return;
maFormulaGroups.set(sindex, pArray);
ScFormulaCell* pCell = new ScFormulaCell(&mrDoc.getDoc(), aPos, *pArray);
mrDoc.setFormulaCell(aPos, pCell);
cellInserted();
// For now, orcus doesn't support setting cached result. Mark it for re-calculation.
pCell->SetDirty(true);
}
void ScOrcusSheet::set_shared_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar, size_t sindex,
const char* p_formula, size_t n_formula, const char* /*p_range*/, size_t /*n_range*/)
{
set_shared_formula(row, col, grammar, sindex, p_formula, n_formula);
}
void ScOrcusSheet::set_shared_formula(os::row_t row, os::col_t col, size_t sindex)
{
ScAddress aPos(col, row, mnTab);
const ScTokenArray* pArray = maFormulaGroups.get(sindex);
if (!pArray)
return;
ScFormulaCell* pCell = new ScFormulaCell(&mrDoc.getDoc(), aPos, *pArray);
mrDoc.setFormulaCell(aPos, pCell);
cellInserted();
// For now, orcus doesn't support setting cached result. Mark it for re-calculation.
pCell->SetDirty(true);
}
void ScOrcusSheet::set_array_formula(
os::row_t /*row*/, os::col_t /*col*/, os::formula_grammar_t /*grammar*/,
const char* /*p*/, size_t /*n*/, os::row_t /*array_rows*/, os::col_t /*array_cols*/)
{
}
void ScOrcusSheet::set_array_formula(
os::row_t /*row*/, os::col_t /*col*/, os::formula_grammar_t /*grammar*/,
const char* /*p*/, size_t /*n*/, const char* /*p_range*/, size_t /*n_range*/)
{
}
ScOrcusSharedStrings::ScOrcusSharedStrings(ScOrcusFactory& rFactory) :
mrFactory(rFactory) {}
size_t ScOrcusSharedStrings::append(const char* s, size_t n)
{
OUString aNewString(s, n, RTL_TEXTENCODING_UTF8);
return mrFactory.appendString(aNewString);
}
size_t ScOrcusSharedStrings::add(const char* s, size_t n)
{
OUString aNewString(s, n, RTL_TEXTENCODING_UTF8);
return mrFactory.addString(aNewString);
}
void ScOrcusSharedStrings::set_segment_font(size_t /*font_index*/)
{
}
void ScOrcusSharedStrings::set_segment_bold(bool /*b*/)
{
}
void ScOrcusSharedStrings::set_segment_italic(bool /*b*/)
{
}
void ScOrcusSharedStrings::set_segment_font_name(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusSharedStrings::set_segment_font_size(double /*point*/)
{
}
void ScOrcusSharedStrings::set_segment_font_color(orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t)
{
}
void ScOrcusSharedStrings::append_segment(const char* s, size_t n)
{
maCurSegment.append(s, n);
}
size_t ScOrcusSharedStrings::commit_segments()
{
OString aStr = maCurSegment.makeStringAndClear();
return mrFactory.addString(OStringToOUString(aStr, RTL_TEXTENCODING_UTF8));
}
void ScOrcusStyles::set_font_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_font_bold(bool /*b*/)
{
}
void ScOrcusStyles::set_font_italic(bool /*b*/)
{
}
void ScOrcusStyles::set_font_name(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusStyles::set_font_size(double /*point*/)
{
}
void ScOrcusStyles::set_font_underline(orcus::spreadsheet::underline_t /*e*/)
{
}
void ScOrcusStyles::set_font_color(orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t)
{
}
size_t ScOrcusStyles::commit_font()
{
return 0;
}
// fill
void ScOrcusStyles::set_fill_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_fill_pattern_type(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusStyles::set_fill_fg_color(orcus::spreadsheet::color_elem_t /*alpha*/, orcus::spreadsheet::color_elem_t /*red*/, orcus::spreadsheet::color_elem_t /*green*/, orcus::spreadsheet::color_elem_t /*blue*/)
{
}
void ScOrcusStyles::set_fill_bg_color(orcus::spreadsheet::color_elem_t /*alpha*/, orcus::spreadsheet::color_elem_t /*red*/, orcus::spreadsheet::color_elem_t /*green*/, orcus::spreadsheet::color_elem_t /*blue*/)
{
}
size_t ScOrcusStyles::commit_fill()
{
return 0;
}
// border
void ScOrcusStyles::set_border_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_border_style(orcus::spreadsheet::border_direction_t /*dir*/, const char* /*s*/, size_t /*n*/)
{
// implement later
}
void ScOrcusStyles::set_border_color(orcus::spreadsheet::border_direction_t /*dir*/,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t)
{
// implement later
}
size_t ScOrcusStyles::commit_border()
{
return 0;
}
// cell protection
void ScOrcusStyles::set_cell_hidden(bool /*b*/)
{
}
void ScOrcusStyles::set_cell_locked(bool /*b*/)
{
}
size_t ScOrcusStyles::commit_cell_protection()
{
return 0;
}
void ScOrcusStyles::set_number_format_count(size_t)
{
}
void ScOrcusStyles::set_number_format_identifier(size_t)
{
}
void ScOrcusStyles::set_number_format_code(const char* /*s*/, size_t /*n*/)
{
}
size_t ScOrcusStyles::commit_number_format()
{
return 0;
}
// cell style xf
void ScOrcusStyles::set_cell_style_xf_count(size_t /*n*/)
{
// needed at all?
}
size_t ScOrcusStyles::commit_cell_style_xf()
{
return 0;
}
// cell xf
void ScOrcusStyles::set_cell_xf_count(size_t /*n*/)
{
// needed at all?
}
size_t ScOrcusStyles::commit_cell_xf()
{
return 0;
}
// xf (cell format) - used both by cell xf and cell style xf.
void ScOrcusStyles::set_xf_number_format(size_t /*index*/)
{
// no number format interfaces implemented yet
}
void ScOrcusStyles::set_xf_font(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_fill(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_border(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_protection(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_style_xf(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_apply_alignment(bool /*b*/)
{
}
void ScOrcusStyles::set_xf_horizontal_alignment(orcus::spreadsheet::hor_alignment_t /*align*/)
{
}
void ScOrcusStyles::set_xf_vertical_alignment(orcus::spreadsheet::ver_alignment_t /*align*/)
{
}
// cell style entry
// not needed for now for gnumeric
void ScOrcusStyles::set_cell_style_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_cell_style_name(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusStyles::set_cell_style_xf(size_t /*index*/)
{
}
void ScOrcusStyles::set_cell_style_builtin(size_t /*index*/)
{
// not needed for gnumeric
}
size_t ScOrcusStyles::commit_cell_style()
{
return 0;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
add array cell import to orcus import
Change-Id: I4f6dab039389e6b07486162df8bf939b557e7ed8
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include "orcusinterface.hxx"
#include "document.hxx"
#include "formulacell.hxx"
#include "rangenam.hxx"
#include "tokenarray.hxx"
#include "globalnames.hxx"
#include "docoptio.hxx"
#include "globstr.hrc"
#include "compiler.hxx"
#include "formula/token.hxx"
#include "tools/datetime.hxx"
#include <com/sun/star/task/XStatusIndicator.hpp>
using namespace com::sun::star;
namespace os = orcus::spreadsheet;
ScOrcusGlobalSettings::ScOrcusGlobalSettings(ScDocumentImport& rDoc) : mrDoc(rDoc) {}
void ScOrcusGlobalSettings::set_origin_date(int year, int month, int day)
{
mrDoc.setOriginDate(year, month, day);
}
ScOrcusFactory::StringCellCache::StringCellCache(const ScAddress& rPos, size_t nIndex) :
maPos(rPos), mnIndex(nIndex) {}
ScOrcusFactory::ScOrcusFactory(ScDocument& rDoc) :
maDoc(rDoc),
maGlobalSettings(maDoc),
maSharedStrings(*this),
mnProgress(0) {}
orcus::spreadsheet::iface::import_sheet* ScOrcusFactory::append_sheet(const char* sheet_name, size_t sheet_name_length)
{
OUString aTabName(sheet_name, sheet_name_length, RTL_TEXTENCODING_UTF8);
if (!maDoc.appendSheet(aTabName))
return NULL;
SCTAB nTab = maDoc.getSheetCount() - 1;
maSheets.push_back(new ScOrcusSheet(maDoc, nTab, *this));
return &maSheets.back();
}
class FindSheetByIndex : std::unary_function<ScOrcusSheet, bool>
{
SCTAB mnTab;
public:
FindSheetByIndex(SCTAB nTab) : mnTab(nTab) {}
bool operator() (const ScOrcusSheet& rSheet) const
{
return rSheet.getIndex() == mnTab;
}
};
orcus::spreadsheet::iface::import_sheet* ScOrcusFactory::get_sheet(const char* sheet_name, size_t sheet_name_length)
{
OUString aTabName(sheet_name, sheet_name_length, RTL_TEXTENCODING_UTF8);
SCTAB nTab = maDoc.getSheetIndex(aTabName);
if (nTab < 0)
// Sheet by that name not found.
return NULL;
// See if we already have an orcus sheet instance by that index.
boost::ptr_vector<ScOrcusSheet>::iterator it =
std::find_if(maSheets.begin(), maSheets.end(), FindSheetByIndex(nTab));
if (it != maSheets.end())
// We already have one. Return it.
return &(*it);
// Create a new orcus sheet instance for this.
maSheets.push_back(new ScOrcusSheet(maDoc, nTab, *this));
return &maSheets.back();
}
orcus::spreadsheet::iface::import_sheet* ScOrcusFactory::get_sheet(orcus::spreadsheet::sheet_t sheet_index)
{
SCTAB nTab = static_cast<SCTAB>(sheet_index);
// See if we already have an orcus sheet instance by that index.
boost::ptr_vector<ScOrcusSheet>::iterator it =
std::find_if(maSheets.begin(), maSheets.end(), FindSheetByIndex(nTab));
if (it != maSheets.end())
// We already have one. Return it.
return &(*it);
// Create a new orcus sheet instance for this.
maSheets.push_back(new ScOrcusSheet(maDoc, nTab, *this));
return &maSheets.back();
}
orcus::spreadsheet::iface::import_global_settings* ScOrcusFactory::get_global_settings()
{
return &maGlobalSettings;
}
orcus::spreadsheet::iface::import_shared_strings* ScOrcusFactory::get_shared_strings()
{
return &maSharedStrings;
}
orcus::spreadsheet::iface::import_styles* ScOrcusFactory::get_styles()
{
return &maStyles;
}
void ScOrcusFactory::finalize()
{
int nCellCount = 0;
StringCellCaches::const_iterator it = maStringCells.begin(), itEnd = maStringCells.end();
for (; it != itEnd; ++it)
{
if (it->mnIndex >= maStrings.size())
// String index out-of-bound! Something is up.
continue;
maDoc.setStringCell(it->maPos, maStrings[it->mnIndex]);
++nCellCount;
if (nCellCount == 100000)
{
incrementProgress();
nCellCount = 0;
}
}
if (mxStatusIndicator.is())
mxStatusIndicator->end();
maDoc.finalize();
}
size_t ScOrcusFactory::appendString(const OUString& rStr)
{
size_t nPos = maStrings.size();
maStrings.push_back(rStr);
maStringHash.insert(StringHashType::value_type(rStr, nPos));
return nPos;
}
size_t ScOrcusFactory::addString(const OUString& rStr)
{
// Add only if the string is not yet present in the string pool.
StringHashType::iterator it = maStringHash.find(rStr);
if (it != maStringHash.end())
return it->second;
return appendString(rStr);
}
void ScOrcusFactory::pushStringCell(const ScAddress& rPos, size_t nStrIndex)
{
maStringCells.push_back(StringCellCache(rPos, nStrIndex));
}
void ScOrcusFactory::incrementProgress()
{
if (!mxStatusIndicator.is())
// Status indicator object not set.
return;
// For now, we'll hard-code the progress range to be 100, and stops at 99
// in all cases.
if (!mnProgress)
mxStatusIndicator->start(ScGlobal::GetRscString(STR_LOAD_DOC), 100);
if (mnProgress == 99)
return;
++mnProgress;
mxStatusIndicator->setValue(mnProgress);
}
void ScOrcusFactory::setStatusIndicator(const uno::Reference<task::XStatusIndicator>& rIndicator)
{
mxStatusIndicator = rIndicator;
}
ScOrcusSheet::ScOrcusSheet(ScDocumentImport& rDoc, SCTAB nTab, ScOrcusFactory& rFactory) :
mrDoc(rDoc), mnTab(nTab), mrFactory(rFactory), mnCellCount(0) {}
void ScOrcusSheet::cellInserted()
{
++mnCellCount;
if (mnCellCount == 100000)
{
mrFactory.incrementProgress();
mnCellCount = 0;
}
}
void ScOrcusSheet::set_auto(os::row_t row, os::col_t col, const char* p, size_t n)
{
OUString aVal(p, n, RTL_TEXTENCODING_UTF8);
mrDoc.setAutoInput(ScAddress(col, row, mnTab), aVal);
cellInserted();
}
void ScOrcusSheet::set_string(os::row_t row, os::col_t col, size_t sindex)
{
// We need to defer string cells since the shared string pool is not yet
// populated at the time this method is called. Orcus imports string
// table after the cells get imported. We won't need to do this once we
// implement true shared strings in Calc core.
mrFactory.pushStringCell(ScAddress(col, row, mnTab), sindex);
cellInserted();
}
void ScOrcusSheet::set_value(os::row_t row, os::col_t col, double value)
{
mrDoc.setNumericCell(ScAddress(col, row, mnTab), value);
cellInserted();
}
void ScOrcusSheet::set_bool(os::row_t row, os::col_t col, bool value)
{
mrDoc.setNumericCell(ScAddress(col, row, mnTab), value ? 1.0 : 0.0);
cellInserted();
}
void ScOrcusSheet::set_date_time(
os::row_t row, os::col_t col, int year, int month, int day, int hour, int minute, double second)
{
SvNumberFormatter* pFormatter = mrDoc.getDoc().GetFormatTable();
Date aDate(day, month, year);
sal_uInt32 nSec = floor(second);
sal_uInt32 nNanoSec = (second - nSec) * ::Time::nanoSecPerSec;
Time aTime(hour, minute, nSec, nNanoSec);
Date aNullDate(*pFormatter->GetNullDate());
long nDateDiff = aDate - aNullDate;
double fTime =
static_cast<double>(aTime.GetNanoSec()) / ::Time::nanoSecPerSec +
aTime.GetSec() +
aTime.GetMin() * ::Time::secondPerMinute +
aTime.GetHour() * ::Time::secondPerHour;
fTime /= DATE_TIME_FACTOR;
mrDoc.setNumericCell(ScAddress(col, row, mnTab), nDateDiff + fTime);
cellInserted();
}
void ScOrcusSheet::set_format(os::row_t /*row*/, os::col_t /*col*/, size_t /*xf_index*/)
{
}
namespace {
formula::FormulaGrammar::Grammar getCalcGrammarFromOrcus( os::formula_grammar_t grammar )
{
formula::FormulaGrammar::Grammar eGrammar = formula::FormulaGrammar::GRAM_ODFF;
switch(grammar)
{
case orcus::spreadsheet::ods:
eGrammar = formula::FormulaGrammar::GRAM_ODFF;
break;
case orcus::spreadsheet::xlsx_2007:
case orcus::spreadsheet::xlsx_2010:
eGrammar = formula::FormulaGrammar::GRAM_OOXML;
break;
case orcus::spreadsheet::gnumeric:
eGrammar = formula::FormulaGrammar::GRAM_ENGLISH_XL_A1;
break;
}
return eGrammar;
}
}
void ScOrcusSheet::set_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar, const char* p, size_t n)
{
OUString aFormula(p, n, RTL_TEXTENCODING_UTF8);
formula::FormulaGrammar::Grammar eGrammar = getCalcGrammarFromOrcus( grammar );
mrDoc.setFormulaCell(ScAddress(col,row,mnTab), aFormula, eGrammar);
cellInserted();
}
void ScOrcusSheet::set_formula_result(os::row_t row, os::col_t col, const char* p, size_t n)
{
ScFormulaCell* pCell = mrDoc.getDoc().GetFormulaCell(ScAddress(col, row, mnTab));
if (!pCell)
{
SAL_WARN("sc", "trying to set formula result for non formula \
cell! Col: " << col << ";Row: " << row << ";Tab: " << mnTab);
return;
}
OUString aResult( p, n, RTL_TEXTENCODING_UTF8);
pCell->SetHybridString(aResult);
}
void ScOrcusSheet::set_shared_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar, size_t sindex,
const char* p_formula, size_t n_formula)
{
ScAddress aPos(col, row, mnTab);
OUString aFormula(p_formula, n_formula, RTL_TEXTENCODING_UTF8);
formula::FormulaGrammar::Grammar eGram = getCalcGrammarFromOrcus(grammar);
// Compile the formula expression into tokens.
ScCompiler aComp(&mrDoc.getDoc(), aPos);
aComp.SetGrammar(eGram);
ScTokenArray* pArray = aComp.CompileString(aFormula);
if (!pArray)
// Tokenization failed.
return;
maFormulaGroups.set(sindex, pArray);
ScFormulaCell* pCell = new ScFormulaCell(&mrDoc.getDoc(), aPos, *pArray);
mrDoc.setFormulaCell(aPos, pCell);
cellInserted();
// For now, orcus doesn't support setting cached result. Mark it for re-calculation.
pCell->SetDirty(true);
}
void ScOrcusSheet::set_shared_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar, size_t sindex,
const char* p_formula, size_t n_formula, const char* /*p_range*/, size_t /*n_range*/)
{
set_shared_formula(row, col, grammar, sindex, p_formula, n_formula);
}
void ScOrcusSheet::set_shared_formula(os::row_t row, os::col_t col, size_t sindex)
{
ScAddress aPos(col, row, mnTab);
const ScTokenArray* pArray = maFormulaGroups.get(sindex);
if (!pArray)
return;
ScFormulaCell* pCell = new ScFormulaCell(&mrDoc.getDoc(), aPos, *pArray);
mrDoc.setFormulaCell(aPos, pCell);
cellInserted();
// For now, orcus doesn't support setting cached result. Mark it for re-calculation.
pCell->SetDirty(true);
}
void ScOrcusSheet::set_array_formula(
os::row_t row, os::col_t col, os::formula_grammar_t grammar,
const char* p, size_t n, os::row_t array_rows, os::col_t array_cols)
{
formula::FormulaGrammar::Grammar eGrammar = getCalcGrammarFromOrcus( grammar );
OUString aFormula(p, n, RTL_TEXTENCODING_UTF8);
ScRange aRange(col, row, mnTab, col+array_cols, row + array_rows, mnTab);
ScCompiler aComp(&mrDoc.getDoc(), aRange.aStart);
aComp.SetGrammar(eGrammar);
boost::scoped_ptr<ScTokenArray> pArray(aComp.CompileString(aFormula));
if (!pArray)
return;
mrDoc.setMatrixCells(aRange, *pArray, eGrammar);
}
void ScOrcusSheet::set_array_formula(
os::row_t /*row*/, os::col_t /*col*/, os::formula_grammar_t /*grammar*/,
const char* /*p*/, size_t /*n*/, const char* /*p_range*/, size_t /*n_range*/)
{
}
ScOrcusSharedStrings::ScOrcusSharedStrings(ScOrcusFactory& rFactory) :
mrFactory(rFactory) {}
size_t ScOrcusSharedStrings::append(const char* s, size_t n)
{
OUString aNewString(s, n, RTL_TEXTENCODING_UTF8);
return mrFactory.appendString(aNewString);
}
size_t ScOrcusSharedStrings::add(const char* s, size_t n)
{
OUString aNewString(s, n, RTL_TEXTENCODING_UTF8);
return mrFactory.addString(aNewString);
}
void ScOrcusSharedStrings::set_segment_font(size_t /*font_index*/)
{
}
void ScOrcusSharedStrings::set_segment_bold(bool /*b*/)
{
}
void ScOrcusSharedStrings::set_segment_italic(bool /*b*/)
{
}
void ScOrcusSharedStrings::set_segment_font_name(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusSharedStrings::set_segment_font_size(double /*point*/)
{
}
void ScOrcusSharedStrings::set_segment_font_color(orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t)
{
}
void ScOrcusSharedStrings::append_segment(const char* s, size_t n)
{
maCurSegment.append(s, n);
}
size_t ScOrcusSharedStrings::commit_segments()
{
OString aStr = maCurSegment.makeStringAndClear();
return mrFactory.addString(OStringToOUString(aStr, RTL_TEXTENCODING_UTF8));
}
void ScOrcusStyles::set_font_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_font_bold(bool /*b*/)
{
}
void ScOrcusStyles::set_font_italic(bool /*b*/)
{
}
void ScOrcusStyles::set_font_name(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusStyles::set_font_size(double /*point*/)
{
}
void ScOrcusStyles::set_font_underline(orcus::spreadsheet::underline_t /*e*/)
{
}
void ScOrcusStyles::set_font_color(orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t)
{
}
size_t ScOrcusStyles::commit_font()
{
return 0;
}
// fill
void ScOrcusStyles::set_fill_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_fill_pattern_type(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusStyles::set_fill_fg_color(orcus::spreadsheet::color_elem_t /*alpha*/, orcus::spreadsheet::color_elem_t /*red*/, orcus::spreadsheet::color_elem_t /*green*/, orcus::spreadsheet::color_elem_t /*blue*/)
{
}
void ScOrcusStyles::set_fill_bg_color(orcus::spreadsheet::color_elem_t /*alpha*/, orcus::spreadsheet::color_elem_t /*red*/, orcus::spreadsheet::color_elem_t /*green*/, orcus::spreadsheet::color_elem_t /*blue*/)
{
}
size_t ScOrcusStyles::commit_fill()
{
return 0;
}
// border
void ScOrcusStyles::set_border_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_border_style(orcus::spreadsheet::border_direction_t /*dir*/, const char* /*s*/, size_t /*n*/)
{
// implement later
}
void ScOrcusStyles::set_border_color(orcus::spreadsheet::border_direction_t /*dir*/,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t,
orcus::spreadsheet::color_elem_t)
{
// implement later
}
size_t ScOrcusStyles::commit_border()
{
return 0;
}
// cell protection
void ScOrcusStyles::set_cell_hidden(bool /*b*/)
{
}
void ScOrcusStyles::set_cell_locked(bool /*b*/)
{
}
size_t ScOrcusStyles::commit_cell_protection()
{
return 0;
}
void ScOrcusStyles::set_number_format_count(size_t)
{
}
void ScOrcusStyles::set_number_format_identifier(size_t)
{
}
void ScOrcusStyles::set_number_format_code(const char* /*s*/, size_t /*n*/)
{
}
size_t ScOrcusStyles::commit_number_format()
{
return 0;
}
// cell style xf
void ScOrcusStyles::set_cell_style_xf_count(size_t /*n*/)
{
// needed at all?
}
size_t ScOrcusStyles::commit_cell_style_xf()
{
return 0;
}
// cell xf
void ScOrcusStyles::set_cell_xf_count(size_t /*n*/)
{
// needed at all?
}
size_t ScOrcusStyles::commit_cell_xf()
{
return 0;
}
// xf (cell format) - used both by cell xf and cell style xf.
void ScOrcusStyles::set_xf_number_format(size_t /*index*/)
{
// no number format interfaces implemented yet
}
void ScOrcusStyles::set_xf_font(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_fill(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_border(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_protection(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_style_xf(size_t /*index*/)
{
}
void ScOrcusStyles::set_xf_apply_alignment(bool /*b*/)
{
}
void ScOrcusStyles::set_xf_horizontal_alignment(orcus::spreadsheet::hor_alignment_t /*align*/)
{
}
void ScOrcusStyles::set_xf_vertical_alignment(orcus::spreadsheet::ver_alignment_t /*align*/)
{
}
// cell style entry
// not needed for now for gnumeric
void ScOrcusStyles::set_cell_style_count(size_t /*n*/)
{
// needed at all?
}
void ScOrcusStyles::set_cell_style_name(const char* /*s*/, size_t /*n*/)
{
}
void ScOrcusStyles::set_cell_style_xf(size_t /*index*/)
{
}
void ScOrcusStyles::set_cell_style_builtin(size_t /*index*/)
{
// not needed for gnumeric
}
size_t ScOrcusStyles::commit_cell_style()
{
return 0;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
/*************************************************************************/
/* primitive_meshes.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "primitive_meshes.h"
#include "servers/visual_server.h"
/**
PrimitiveMesh
*/
void PrimitiveMesh::_update() const {
Array arr;
arr.resize(VS::ARRAY_MAX);
_create_mesh_array(arr);
PoolVector<Vector3> points = arr[VS::ARRAY_VERTEX];
aabb = AABB();
int pc = points.size();
ERR_FAIL_COND(pc == 0);
{
PoolVector<Vector3>::Read r = points.read();
for (int i = 0; i < pc; i++) {
if (i == 0)
aabb.position = r[i];
else
aabb.expand_to(r[i]);
}
}
// in with the new
VisualServer::get_singleton()->mesh_clear(mesh);
VisualServer::get_singleton()->mesh_add_surface_from_arrays(mesh, (VisualServer::PrimitiveType)primitive_type, arr);
VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid());
pending_request = false;
_clear_triangle_mesh();
}
void PrimitiveMesh::_request_update() {
if (pending_request)
return;
_update();
}
int PrimitiveMesh::get_surface_count() const {
return 1;
}
int PrimitiveMesh::surface_get_array_len(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, -1);
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_array_len(mesh, 0);
}
int PrimitiveMesh::surface_get_array_index_len(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, -1);
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_array_index_len(mesh, 0);
}
Array PrimitiveMesh::surface_get_arrays(int p_surface) const {
ERR_FAIL_INDEX_V(p_surface, 1, Array());
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_arrays(mesh, 0);
}
Array PrimitiveMesh::surface_get_blend_shape_arrays(int p_surface) const {
ERR_FAIL_INDEX_V(p_surface, 1, Array());
if (pending_request) {
_update();
}
return Array();
}
uint32_t PrimitiveMesh::surface_get_format(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, 0);
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_format(mesh, 0);
}
Mesh::PrimitiveType PrimitiveMesh::surface_get_primitive_type(int p_idx) const {
return primitive_type;
}
Ref<Material> PrimitiveMesh::surface_get_material(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, NULL);
return material;
}
int PrimitiveMesh::get_blend_shape_count() const {
return 0;
}
StringName PrimitiveMesh::get_blend_shape_name(int p_index) const {
return StringName();
}
AABB PrimitiveMesh::get_aabb() const {
if (pending_request) {
_update();
}
return aabb;
}
RID PrimitiveMesh::get_rid() const {
if (pending_request) {
_update();
}
return mesh;
}
void PrimitiveMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("_update"), &PrimitiveMesh::_update);
ClassDB::bind_method(D_METHOD("set_material", "material"), &PrimitiveMesh::set_material);
ClassDB::bind_method(D_METHOD("get_material"), &PrimitiveMesh::get_material);
ClassDB::bind_method(D_METHOD("get_mesh_arrays"), &PrimitiveMesh::get_mesh_arrays);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
}
void PrimitiveMesh::set_material(const Ref<Material> &p_material) {
material = p_material;
if (!pending_request) {
// just apply it, else it'll happen when _update is called.
VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid());
_change_notify();
emit_changed();
};
}
Ref<Material> PrimitiveMesh::get_material() const {
return material;
}
Array PrimitiveMesh::get_mesh_arrays() const {
return surface_get_arrays(0);
}
PrimitiveMesh::PrimitiveMesh() {
// defaults
mesh = VisualServer::get_singleton()->mesh_create();
// assume primitive triangles as the type, correct for all but one and it will change this :)
primitive_type = Mesh::PRIMITIVE_TRIANGLES;
// make sure we do an update after we've finished constructing our object
pending_request = true;
}
PrimitiveMesh::~PrimitiveMesh() {
VisualServer::get_singleton()->free(mesh);
}
/**
CapsuleMesh
*/
void CapsuleMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z, u, v, w;
float onethird = 1.0 / 3.0;
float twothirds = 2.0 / 3.0;
// note, this has been aligned with our collision shape but I've left the descriptions as top/middle/bottom
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
/* top hemisphere */
thisrow = 0;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
w = sin(0.5 * Math_PI * v);
z = radius * cos(0.5 * Math_PI * v);
for (i = 0; i <= radial_segments; i++) {
u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
y = -cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius * w, y * radius * w, z);
points.push_back(p + Vector3(0.0, 0.0, 0.5 * mid_height));
normals.push_back(p.normalized());
ADD_TANGENT(y, -x, 0.0, -1.0)
uvs.push_back(Vector2(u, v * onethird));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
/* cylinder */
thisrow = point;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
z = mid_height * v;
z = (mid_height * 0.5) - z;
for (i = 0; i <= radial_segments; i++) {
u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
y = -cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius, y * radius, z);
points.push_back(p);
normals.push_back(Vector3(x, y, 0.0));
ADD_TANGENT(y, -x, 0.0, -1.0)
uvs.push_back(Vector2(u, onethird + (v * onethird)));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
/* bottom hemisphere */
thisrow = point;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
v += 1.0;
w = sin(0.5 * Math_PI * v);
z = radius * cos(0.5 * Math_PI * v);
for (i = 0; i <= radial_segments; i++) {
float u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
y = -cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius * w, y * radius * w, z);
points.push_back(p + Vector3(0.0, 0.0, -0.5 * mid_height));
normals.push_back(p.normalized());
ADD_TANGENT(y, -x, 0.0, -1.0)
uvs.push_back(Vector2(u, twothirds + ((v - 1.0) * onethird)));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void CapsuleMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_radius", "radius"), &CapsuleMesh::set_radius);
ClassDB::bind_method(D_METHOD("get_radius"), &CapsuleMesh::get_radius);
ClassDB::bind_method(D_METHOD("set_mid_height", "mid_height"), &CapsuleMesh::set_mid_height);
ClassDB::bind_method(D_METHOD("get_mid_height"), &CapsuleMesh::get_mid_height);
ClassDB::bind_method(D_METHOD("set_radial_segments", "segments"), &CapsuleMesh::set_radial_segments);
ClassDB::bind_method(D_METHOD("get_radial_segments"), &CapsuleMesh::get_radial_segments);
ClassDB::bind_method(D_METHOD("set_rings", "rings"), &CapsuleMesh::set_rings);
ClassDB::bind_method(D_METHOD("get_rings"), &CapsuleMesh::get_rings);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_radius", "get_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "mid_height", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_mid_height", "get_mid_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
}
void CapsuleMesh::set_radius(const float p_radius) {
radius = p_radius;
_request_update();
}
float CapsuleMesh::get_radius() const {
return radius;
}
void CapsuleMesh::set_mid_height(const float p_mid_height) {
mid_height = p_mid_height;
_request_update();
}
float CapsuleMesh::get_mid_height() const {
return mid_height;
}
void CapsuleMesh::set_radial_segments(const int p_segments) {
radial_segments = p_segments > 4 ? p_segments : 4;
_request_update();
}
int CapsuleMesh::get_radial_segments() const {
return radial_segments;
}
void CapsuleMesh::set_rings(const int p_rings) {
rings = p_rings > 1 ? p_rings : 1;
_request_update();
}
int CapsuleMesh::get_rings() const {
return rings;
}
CapsuleMesh::CapsuleMesh() {
// defaults
radius = 1.0;
mid_height = 1.0;
radial_segments = 64;
rings = 8;
}
/**
CubeMesh
*/
void CubeMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z;
float onethird = 1.0 / 3.0;
float twothirds = 2.0 / 3.0;
Vector3 start_pos = size * -0.5;
// set our bounding box
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
// front + back
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= subdivide_h + 1; j++) {
x = start_pos.x;
for (i = 0; i <= subdivide_w + 1; i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
// front
points.push_back(Vector3(x, -y, -start_pos.z)); // double negative on the Z!
normals.push_back(Vector3(0.0, 0.0, 1.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(u, v));
point++;
// back
points.push_back(Vector3(-x, -y, start_pos.z));
normals.push_back(Vector3(0.0, 0.0, -1.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + u, v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
// front
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
// back
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
x += size.x / (subdivide_w + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
// left + right
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_h + 1); j++) {
z = start_pos.z;
for (i = 0; i <= (subdivide_d + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_d + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
// right
points.push_back(Vector3(-start_pos.x, -y, -z));
normals.push_back(Vector3(1.0, 0.0, 0.0));
ADD_TANGENT(0.0, 0.0, 1.0, -1.0);
uvs.push_back(Vector2(onethird + u, v));
point++;
// left
points.push_back(Vector3(start_pos.x, -y, z));
normals.push_back(Vector3(-1.0, 0.0, 0.0));
ADD_TANGENT(0.0, 0.0, -1.0, -1.0);
uvs.push_back(Vector2(u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
// right
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
// left
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
z += size.z / (subdivide_d + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
// top + bottom
z = start_pos.z;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_d + 1); j++) {
x = start_pos.x;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_d + 1.0));
// top
points.push_back(Vector3(-x, -start_pos.y, -z));
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(onethird + u, 0.5 + v));
point++;
// bottom
points.push_back(Vector3(x, start_pos.y, -z));
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
// top
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
// bottom
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
x += size.x / (subdivide_w + 1.0);
};
z += size.z / (subdivide_d + 1.0);
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void CubeMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_size", "size"), &CubeMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &CubeMesh::get_size);
ClassDB::bind_method(D_METHOD("set_subdivide_width", "subdivide"), &CubeMesh::set_subdivide_width);
ClassDB::bind_method(D_METHOD("get_subdivide_width"), &CubeMesh::get_subdivide_width);
ClassDB::bind_method(D_METHOD("set_subdivide_height", "divisions"), &CubeMesh::set_subdivide_height);
ClassDB::bind_method(D_METHOD("get_subdivide_height"), &CubeMesh::get_subdivide_height);
ClassDB::bind_method(D_METHOD("set_subdivide_depth", "divisions"), &CubeMesh::set_subdivide_depth);
ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &CubeMesh::get_subdivide_depth);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_height", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_height", "get_subdivide_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
}
void CubeMesh::set_size(const Vector3 &p_size) {
size = p_size;
_request_update();
}
Vector3 CubeMesh::get_size() const {
return size;
}
void CubeMesh::set_subdivide_width(const int p_divisions) {
subdivide_w = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int CubeMesh::get_subdivide_width() const {
return subdivide_w;
}
void CubeMesh::set_subdivide_height(const int p_divisions) {
subdivide_h = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int CubeMesh::get_subdivide_height() const {
return subdivide_h;
}
void CubeMesh::set_subdivide_depth(const int p_divisions) {
subdivide_d = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int CubeMesh::get_subdivide_depth() const {
return subdivide_d;
}
CubeMesh::CubeMesh() {
// defaults
size = Vector3(2.0, 2.0, 2.0);
subdivide_w = 0;
subdivide_h = 0;
subdivide_d = 0;
}
/**
CylinderMesh
*/
void CylinderMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z, u, v, radius;
radius = bottom_radius > top_radius ? bottom_radius : top_radius;
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
thisrow = 0;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
radius = top_radius + ((bottom_radius - top_radius) * v);
y = height * v;
y = (height * 0.5) - y;
for (i = 0; i <= radial_segments; i++) {
u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
z = cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius, y, z * radius);
points.push_back(p);
normals.push_back(Vector3(x, 0.0, z));
ADD_TANGENT(-z, 0.0, x, -1.0)
uvs.push_back(Vector2(u, v * 0.5));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
// add top
if (top_radius > 0.0) {
y = height * 0.5;
thisrow = point;
points.push_back(Vector3(0.0, y, 0.0));
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, 1.0)
uvs.push_back(Vector2(0.25, 0.75));
point++;
for (i = 0; i <= radial_segments; i++) {
float r = i;
r /= radial_segments;
x = sin(r * (Math_PI * 2.0));
z = cos(r * (Math_PI * 2.0));
u = ((x + 1.0) * 0.25);
v = 0.5 + ((z + 1.0) * 0.25);
Vector3 p = Vector3(x * top_radius, y, z * top_radius);
points.push_back(p);
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, 1.0)
uvs.push_back(Vector2(u, v));
point++;
if (i > 0) {
indices.push_back(thisrow);
indices.push_back(point - 1);
indices.push_back(point - 2);
};
};
};
// add bottom
if (bottom_radius > 0.0) {
y = height * -0.5;
thisrow = point;
points.push_back(Vector3(0.0, y, 0.0));
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0)
uvs.push_back(Vector2(0.75, 0.75));
point++;
for (i = 0; i <= radial_segments; i++) {
float r = i;
r /= radial_segments;
x = sin(r * (Math_PI * 2.0));
z = cos(r * (Math_PI * 2.0));
u = 0.5 + ((x + 1.0) * 0.25);
v = 1.0 - ((z + 1.0) * 0.25);
Vector3 p = Vector3(x * bottom_radius, y, z * bottom_radius);
points.push_back(p);
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0)
uvs.push_back(Vector2(u, v));
point++;
if (i > 0) {
indices.push_back(thisrow);
indices.push_back(point - 2);
indices.push_back(point - 1);
};
};
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void CylinderMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_top_radius", "radius"), &CylinderMesh::set_top_radius);
ClassDB::bind_method(D_METHOD("get_top_radius"), &CylinderMesh::get_top_radius);
ClassDB::bind_method(D_METHOD("set_bottom_radius", "radius"), &CylinderMesh::set_bottom_radius);
ClassDB::bind_method(D_METHOD("get_bottom_radius"), &CylinderMesh::get_bottom_radius);
ClassDB::bind_method(D_METHOD("set_height", "height"), &CylinderMesh::set_height);
ClassDB::bind_method(D_METHOD("get_height"), &CylinderMesh::get_height);
ClassDB::bind_method(D_METHOD("set_radial_segments", "segments"), &CylinderMesh::set_radial_segments);
ClassDB::bind_method(D_METHOD("get_radial_segments"), &CylinderMesh::get_radial_segments);
ClassDB::bind_method(D_METHOD("set_rings", "rings"), &CylinderMesh::set_rings);
ClassDB::bind_method(D_METHOD("get_rings"), &CylinderMesh::get_rings);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "top_radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_top_radius", "get_top_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "bottom_radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_bottom_radius", "get_bottom_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_height", "get_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
}
void CylinderMesh::set_top_radius(const float p_radius) {
top_radius = p_radius;
_request_update();
}
float CylinderMesh::get_top_radius() const {
return top_radius;
}
void CylinderMesh::set_bottom_radius(const float p_radius) {
bottom_radius = p_radius;
_request_update();
}
float CylinderMesh::get_bottom_radius() const {
return bottom_radius;
}
void CylinderMesh::set_height(const float p_height) {
height = p_height;
_request_update();
}
float CylinderMesh::get_height() const {
return height;
}
void CylinderMesh::set_radial_segments(const int p_segments) {
radial_segments = p_segments > 4 ? p_segments : 4;
_request_update();
}
int CylinderMesh::get_radial_segments() const {
return radial_segments;
}
void CylinderMesh::set_rings(const int p_rings) {
rings = p_rings > 0 ? p_rings : 0;
_request_update();
}
int CylinderMesh::get_rings() const {
return rings;
}
CylinderMesh::CylinderMesh() {
// defaults
top_radius = 1.0;
bottom_radius = 1.0;
height = 2.0;
radial_segments = 64;
rings = 4;
}
/**
PlaneMesh
*/
void PlaneMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, z;
Size2 start_pos = size * -0.5;
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
/* top + bottom */
z = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_d + 1); j++) {
x = start_pos.x;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (subdivide_w + 1.0);
v /= (subdivide_d + 1.0);
points.push_back(Vector3(-x, 0.0, -z));
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(u, v));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
x += size.x / (subdivide_w + 1.0);
};
z += size.y / (subdivide_d + 1.0);
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void PlaneMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_size", "size"), &PlaneMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &PlaneMesh::get_size);
ClassDB::bind_method(D_METHOD("set_subdivide_width", "subdivide"), &PlaneMesh::set_subdivide_width);
ClassDB::bind_method(D_METHOD("get_subdivide_width"), &PlaneMesh::get_subdivide_width);
ClassDB::bind_method(D_METHOD("set_subdivide_depth", "subdivide"), &PlaneMesh::set_subdivide_depth);
ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &PlaneMesh::get_subdivide_depth);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
}
void PlaneMesh::set_size(const Size2 &p_size) {
size = p_size;
_request_update();
}
Size2 PlaneMesh::get_size() const {
return size;
}
void PlaneMesh::set_subdivide_width(const int p_divisions) {
subdivide_w = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PlaneMesh::get_subdivide_width() const {
return subdivide_w;
}
void PlaneMesh::set_subdivide_depth(const int p_divisions) {
subdivide_d = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PlaneMesh::get_subdivide_depth() const {
return subdivide_d;
}
PlaneMesh::PlaneMesh() {
// defaults
size = Size2(2.0, 2.0);
subdivide_w = 0;
subdivide_d = 0;
}
/**
PrismMesh
*/
void PrismMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z;
float onethird = 1.0 / 3.0;
float twothirds = 2.0 / 3.0;
Vector3 start_pos = size * -0.5;
// set our bounding box
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
/* front + back */
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_h + 1); j++) {
float scale = (y - start_pos.y) / size.y;
float scaled_size_x = size.x * scale;
float start_x = start_pos.x + (1.0 - scale) * size.x * left_to_right;
float offset_front = (1.0 - scale) * onethird * left_to_right;
float offset_back = (1.0 - scale) * onethird * (1.0 - left_to_right);
x = 0.0;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
u *= scale;
/* front */
points.push_back(Vector3(start_x + x, -y, -start_pos.z)); // double negative on the Z!
normals.push_back(Vector3(0.0, 0.0, 1.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(offset_front + u, v));
point++;
/* back */
points.push_back(Vector3(start_x + scaled_size_x - x, -y, start_pos.z));
normals.push_back(Vector3(0.0, 0.0, -1.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + offset_back + u, v));
point++;
if (i > 0 && j == 1) {
int i2 = i * 2;
/* front */
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
/* back */
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
} else if (i > 0 && j > 0) {
int i2 = i * 2;
/* front */
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
/* back */
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
x += scale * size.x / (subdivide_w + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
/* left + right */
Vector3 normal_left, normal_right;
normal_left = Vector3(-size.y, size.x * left_to_right, 0.0);
normal_right = Vector3(size.y, size.x * left_to_right, 0.0);
normal_left.normalize();
normal_right.normalize();
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_h + 1); j++) {
float left, right;
float scale = (y - start_pos.y) / size.y;
left = start_pos.x + (size.x * (1.0 - scale) * left_to_right);
right = left + (size.x * scale);
z = start_pos.z;
for (i = 0; i <= (subdivide_d + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_d + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
/* right */
points.push_back(Vector3(right, -y, -z));
normals.push_back(normal_right);
ADD_TANGENT(0.0, 0.0, 1.0, -1.0);
uvs.push_back(Vector2(onethird + u, v));
point++;
/* left */
points.push_back(Vector3(left, -y, z));
normals.push_back(normal_left);
ADD_TANGENT(0.0, 0.0, -1.0, -1.0);
uvs.push_back(Vector2(u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
/* right */
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
/* left */
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
z += size.z / (subdivide_d + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
/* bottom */
z = start_pos.z;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_d + 1); j++) {
x = start_pos.x;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_d + 1.0));
/* bottom */
points.push_back(Vector3(x, start_pos.y, -z));
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
/* bottom */
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
x += size.x / (subdivide_w + 1.0);
};
z += size.z / (subdivide_d + 1.0);
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void PrismMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_left_to_right", "left_to_right"), &PrismMesh::set_left_to_right);
ClassDB::bind_method(D_METHOD("get_left_to_right"), &PrismMesh::get_left_to_right);
ClassDB::bind_method(D_METHOD("set_size", "size"), &PrismMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &PrismMesh::get_size);
ClassDB::bind_method(D_METHOD("set_subdivide_width", "segments"), &PrismMesh::set_subdivide_width);
ClassDB::bind_method(D_METHOD("get_subdivide_width"), &PrismMesh::get_subdivide_width);
ClassDB::bind_method(D_METHOD("set_subdivide_height", "segments"), &PrismMesh::set_subdivide_height);
ClassDB::bind_method(D_METHOD("get_subdivide_height"), &PrismMesh::get_subdivide_height);
ClassDB::bind_method(D_METHOD("set_subdivide_depth", "segments"), &PrismMesh::set_subdivide_depth);
ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &PrismMesh::get_subdivide_depth);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "left_to_right", PROPERTY_HINT_RANGE, "-2.0,2.0,0.1"), "set_left_to_right", "get_left_to_right");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_height", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_height", "get_subdivide_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
}
void PrismMesh::set_left_to_right(const float p_left_to_right) {
left_to_right = p_left_to_right;
_request_update();
}
float PrismMesh::get_left_to_right() const {
return left_to_right;
}
void PrismMesh::set_size(const Vector3 &p_size) {
size = p_size;
_request_update();
}
Vector3 PrismMesh::get_size() const {
return size;
}
void PrismMesh::set_subdivide_width(const int p_divisions) {
subdivide_w = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PrismMesh::get_subdivide_width() const {
return subdivide_w;
}
void PrismMesh::set_subdivide_height(const int p_divisions) {
subdivide_h = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PrismMesh::get_subdivide_height() const {
return subdivide_h;
}
void PrismMesh::set_subdivide_depth(const int p_divisions) {
subdivide_d = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PrismMesh::get_subdivide_depth() const {
return subdivide_d;
}
PrismMesh::PrismMesh() {
// defaults
left_to_right = 0.5;
size = Vector3(2.0, 2.0, 2.0);
subdivide_w = 0;
subdivide_h = 0;
subdivide_d = 0;
}
/**
QuadMesh
*/
void QuadMesh::_create_mesh_array(Array &p_arr) const {
PoolVector<Vector3> faces;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
faces.resize(4);
normals.resize(4);
tangents.resize(4 * 4);
uvs.resize(4);
Vector2 _size = Vector2(size.x / 2.0f, size.y / 2.0f);
Vector3 quad_faces[4] = {
Vector3(-_size.x, -_size.y, 0),
Vector3(-_size.x, _size.y, 0),
Vector3(_size.x, _size.y, 0),
Vector3(_size.x, -_size.y, 0),
};
for (int i = 0; i < 4; i++) {
faces.set(i, quad_faces[i]);
normals.set(i, Vector3(0, 0, 1));
tangents.set(i * 4 + 0, 1.0);
tangents.set(i * 4 + 1, 0.0);
tangents.set(i * 4 + 2, 0.0);
tangents.set(i * 4 + 3, 1.0);
static const Vector2 quad_uv[4] = {
Vector2(0, 1),
Vector2(0, 0),
Vector2(1, 0),
Vector2(1, 1),
};
uvs.set(i, quad_uv[i]);
}
p_arr[VS::ARRAY_VERTEX] = faces;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
};
void QuadMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_size", "size"), &QuadMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &QuadMesh::get_size);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
}
QuadMesh::QuadMesh() {
primitive_type = PRIMITIVE_TRIANGLE_FAN;
size = Size2(1.0, 1.0);
}
void QuadMesh::set_size(const Size2 &p_size) {
size = p_size;
_request_update();
}
Size2 QuadMesh::get_size() const {
return size;
}
/**
SphereMesh
*/
void SphereMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z;
// set our bounding box
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
thisrow = 0;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
float v = j;
float w;
v /= (rings + 1);
w = sin(Math_PI * v);
y = height * (is_hemisphere ? 1.0 : 0.5) * cos(Math_PI * v);
for (i = 0; i <= radial_segments; i++) {
float u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
z = cos(u * (Math_PI * 2.0));
if (is_hemisphere && y < 0.0) {
points.push_back(Vector3(x * radius * w, 0.0, z * radius * w));
normals.push_back(Vector3(0.0, -1.0, 0.0));
} else {
Vector3 p = Vector3(x * radius * w, y, z * radius * w);
points.push_back(p);
normals.push_back(p.normalized());
};
ADD_TANGENT(-z, 0.0, x, -1.0)
uvs.push_back(Vector2(u, v));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void SphereMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_radius", "radius"), &SphereMesh::set_radius);
ClassDB::bind_method(D_METHOD("get_radius"), &SphereMesh::get_radius);
ClassDB::bind_method(D_METHOD("set_height", "height"), &SphereMesh::set_height);
ClassDB::bind_method(D_METHOD("get_height"), &SphereMesh::get_height);
ClassDB::bind_method(D_METHOD("set_radial_segments", "radial_segments"), &SphereMesh::set_radial_segments);
ClassDB::bind_method(D_METHOD("get_radial_segments"), &SphereMesh::get_radial_segments);
ClassDB::bind_method(D_METHOD("set_rings", "rings"), &SphereMesh::set_rings);
ClassDB::bind_method(D_METHOD("get_rings"), &SphereMesh::get_rings);
ClassDB::bind_method(D_METHOD("set_is_hemisphere", "is_hemisphere"), &SphereMesh::set_is_hemisphere);
ClassDB::bind_method(D_METHOD("get_is_hemisphere"), &SphereMesh::get_is_hemisphere);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_radius", "get_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_RANGE, "0.1,100.0,0.1"), "set_height", "get_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_hemisphere"), "set_is_hemisphere", "get_is_hemisphere");
}
void SphereMesh::set_radius(const float p_radius) {
radius = p_radius;
_request_update();
}
float SphereMesh::get_radius() const {
return radius;
}
void SphereMesh::set_height(const float p_height) {
height = p_height;
_request_update();
}
float SphereMesh::get_height() const {
return height;
}
void SphereMesh::set_radial_segments(const int p_radial_segments) {
radial_segments = p_radial_segments > 4 ? p_radial_segments : 4;
_request_update();
}
int SphereMesh::get_radial_segments() const {
return radial_segments;
}
void SphereMesh::set_rings(const int p_rings) {
rings = p_rings > 1 ? p_rings : 1;
_request_update();
}
int SphereMesh::get_rings() const {
return rings;
}
void SphereMesh::set_is_hemisphere(const bool p_is_hemisphere) {
is_hemisphere = p_is_hemisphere;
_request_update();
}
bool SphereMesh::get_is_hemisphere() const {
return is_hemisphere;
}
SphereMesh::SphereMesh() {
// defaults
radius = 1.0;
height = 2.0;
radial_segments = 64;
rings = 32;
is_hemisphere = false;
}
Change primitive meshes acccuracy value
/*************************************************************************/
/* primitive_meshes.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "primitive_meshes.h"
#include "servers/visual_server.h"
/**
PrimitiveMesh
*/
void PrimitiveMesh::_update() const {
Array arr;
arr.resize(VS::ARRAY_MAX);
_create_mesh_array(arr);
PoolVector<Vector3> points = arr[VS::ARRAY_VERTEX];
aabb = AABB();
int pc = points.size();
ERR_FAIL_COND(pc == 0);
{
PoolVector<Vector3>::Read r = points.read();
for (int i = 0; i < pc; i++) {
if (i == 0)
aabb.position = r[i];
else
aabb.expand_to(r[i]);
}
}
// in with the new
VisualServer::get_singleton()->mesh_clear(mesh);
VisualServer::get_singleton()->mesh_add_surface_from_arrays(mesh, (VisualServer::PrimitiveType)primitive_type, arr);
VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid());
pending_request = false;
_clear_triangle_mesh();
}
void PrimitiveMesh::_request_update() {
if (pending_request)
return;
_update();
}
int PrimitiveMesh::get_surface_count() const {
return 1;
}
int PrimitiveMesh::surface_get_array_len(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, -1);
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_array_len(mesh, 0);
}
int PrimitiveMesh::surface_get_array_index_len(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, -1);
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_array_index_len(mesh, 0);
}
Array PrimitiveMesh::surface_get_arrays(int p_surface) const {
ERR_FAIL_INDEX_V(p_surface, 1, Array());
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_arrays(mesh, 0);
}
Array PrimitiveMesh::surface_get_blend_shape_arrays(int p_surface) const {
ERR_FAIL_INDEX_V(p_surface, 1, Array());
if (pending_request) {
_update();
}
return Array();
}
uint32_t PrimitiveMesh::surface_get_format(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, 0);
if (pending_request) {
_update();
}
return VisualServer::get_singleton()->mesh_surface_get_format(mesh, 0);
}
Mesh::PrimitiveType PrimitiveMesh::surface_get_primitive_type(int p_idx) const {
return primitive_type;
}
Ref<Material> PrimitiveMesh::surface_get_material(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, 1, NULL);
return material;
}
int PrimitiveMesh::get_blend_shape_count() const {
return 0;
}
StringName PrimitiveMesh::get_blend_shape_name(int p_index) const {
return StringName();
}
AABB PrimitiveMesh::get_aabb() const {
if (pending_request) {
_update();
}
return aabb;
}
RID PrimitiveMesh::get_rid() const {
if (pending_request) {
_update();
}
return mesh;
}
void PrimitiveMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("_update"), &PrimitiveMesh::_update);
ClassDB::bind_method(D_METHOD("set_material", "material"), &PrimitiveMesh::set_material);
ClassDB::bind_method(D_METHOD("get_material"), &PrimitiveMesh::get_material);
ClassDB::bind_method(D_METHOD("get_mesh_arrays"), &PrimitiveMesh::get_mesh_arrays);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
}
void PrimitiveMesh::set_material(const Ref<Material> &p_material) {
material = p_material;
if (!pending_request) {
// just apply it, else it'll happen when _update is called.
VisualServer::get_singleton()->mesh_surface_set_material(mesh, 0, material.is_null() ? RID() : material->get_rid());
_change_notify();
emit_changed();
};
}
Ref<Material> PrimitiveMesh::get_material() const {
return material;
}
Array PrimitiveMesh::get_mesh_arrays() const {
return surface_get_arrays(0);
}
PrimitiveMesh::PrimitiveMesh() {
// defaults
mesh = VisualServer::get_singleton()->mesh_create();
// assume primitive triangles as the type, correct for all but one and it will change this :)
primitive_type = Mesh::PRIMITIVE_TRIANGLES;
// make sure we do an update after we've finished constructing our object
pending_request = true;
}
PrimitiveMesh::~PrimitiveMesh() {
VisualServer::get_singleton()->free(mesh);
}
/**
CapsuleMesh
*/
void CapsuleMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z, u, v, w;
float onethird = 1.0 / 3.0;
float twothirds = 2.0 / 3.0;
// note, this has been aligned with our collision shape but I've left the descriptions as top/middle/bottom
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
/* top hemisphere */
thisrow = 0;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
w = sin(0.5 * Math_PI * v);
z = radius * cos(0.5 * Math_PI * v);
for (i = 0; i <= radial_segments; i++) {
u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
y = -cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius * w, y * radius * w, z);
points.push_back(p + Vector3(0.0, 0.0, 0.5 * mid_height));
normals.push_back(p.normalized());
ADD_TANGENT(y, -x, 0.0, -1.0)
uvs.push_back(Vector2(u, v * onethird));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
/* cylinder */
thisrow = point;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
z = mid_height * v;
z = (mid_height * 0.5) - z;
for (i = 0; i <= radial_segments; i++) {
u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
y = -cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius, y * radius, z);
points.push_back(p);
normals.push_back(Vector3(x, y, 0.0));
ADD_TANGENT(y, -x, 0.0, -1.0)
uvs.push_back(Vector2(u, onethird + (v * onethird)));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
/* bottom hemisphere */
thisrow = point;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
v += 1.0;
w = sin(0.5 * Math_PI * v);
z = radius * cos(0.5 * Math_PI * v);
for (i = 0; i <= radial_segments; i++) {
float u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
y = -cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius * w, y * radius * w, z);
points.push_back(p + Vector3(0.0, 0.0, -0.5 * mid_height));
normals.push_back(p.normalized());
ADD_TANGENT(y, -x, 0.0, -1.0)
uvs.push_back(Vector2(u, twothirds + ((v - 1.0) * onethird)));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void CapsuleMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_radius", "radius"), &CapsuleMesh::set_radius);
ClassDB::bind_method(D_METHOD("get_radius"), &CapsuleMesh::get_radius);
ClassDB::bind_method(D_METHOD("set_mid_height", "mid_height"), &CapsuleMesh::set_mid_height);
ClassDB::bind_method(D_METHOD("get_mid_height"), &CapsuleMesh::get_mid_height);
ClassDB::bind_method(D_METHOD("set_radial_segments", "segments"), &CapsuleMesh::set_radial_segments);
ClassDB::bind_method(D_METHOD("get_radial_segments"), &CapsuleMesh::get_radial_segments);
ClassDB::bind_method(D_METHOD("set_rings", "rings"), &CapsuleMesh::set_rings);
ClassDB::bind_method(D_METHOD("get_rings"), &CapsuleMesh::get_rings);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_radius", "get_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "mid_height", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_mid_height", "get_mid_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
}
void CapsuleMesh::set_radius(const float p_radius) {
radius = p_radius;
_request_update();
}
float CapsuleMesh::get_radius() const {
return radius;
}
void CapsuleMesh::set_mid_height(const float p_mid_height) {
mid_height = p_mid_height;
_request_update();
}
float CapsuleMesh::get_mid_height() const {
return mid_height;
}
void CapsuleMesh::set_radial_segments(const int p_segments) {
radial_segments = p_segments > 4 ? p_segments : 4;
_request_update();
}
int CapsuleMesh::get_radial_segments() const {
return radial_segments;
}
void CapsuleMesh::set_rings(const int p_rings) {
rings = p_rings > 1 ? p_rings : 1;
_request_update();
}
int CapsuleMesh::get_rings() const {
return rings;
}
CapsuleMesh::CapsuleMesh() {
// defaults
radius = 1.0;
mid_height = 1.0;
radial_segments = 64;
rings = 8;
}
/**
CubeMesh
*/
void CubeMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z;
float onethird = 1.0 / 3.0;
float twothirds = 2.0 / 3.0;
Vector3 start_pos = size * -0.5;
// set our bounding box
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
// front + back
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= subdivide_h + 1; j++) {
x = start_pos.x;
for (i = 0; i <= subdivide_w + 1; i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
// front
points.push_back(Vector3(x, -y, -start_pos.z)); // double negative on the Z!
normals.push_back(Vector3(0.0, 0.0, 1.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(u, v));
point++;
// back
points.push_back(Vector3(-x, -y, start_pos.z));
normals.push_back(Vector3(0.0, 0.0, -1.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + u, v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
// front
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
// back
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
x += size.x / (subdivide_w + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
// left + right
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_h + 1); j++) {
z = start_pos.z;
for (i = 0; i <= (subdivide_d + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_d + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
// right
points.push_back(Vector3(-start_pos.x, -y, -z));
normals.push_back(Vector3(1.0, 0.0, 0.0));
ADD_TANGENT(0.0, 0.0, 1.0, -1.0);
uvs.push_back(Vector2(onethird + u, v));
point++;
// left
points.push_back(Vector3(start_pos.x, -y, z));
normals.push_back(Vector3(-1.0, 0.0, 0.0));
ADD_TANGENT(0.0, 0.0, -1.0, -1.0);
uvs.push_back(Vector2(u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
// right
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
// left
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
z += size.z / (subdivide_d + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
// top + bottom
z = start_pos.z;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_d + 1); j++) {
x = start_pos.x;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_d + 1.0));
// top
points.push_back(Vector3(-x, -start_pos.y, -z));
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(onethird + u, 0.5 + v));
point++;
// bottom
points.push_back(Vector3(x, start_pos.y, -z));
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
// top
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
// bottom
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
x += size.x / (subdivide_w + 1.0);
};
z += size.z / (subdivide_d + 1.0);
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void CubeMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_size", "size"), &CubeMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &CubeMesh::get_size);
ClassDB::bind_method(D_METHOD("set_subdivide_width", "subdivide"), &CubeMesh::set_subdivide_width);
ClassDB::bind_method(D_METHOD("get_subdivide_width"), &CubeMesh::get_subdivide_width);
ClassDB::bind_method(D_METHOD("set_subdivide_height", "divisions"), &CubeMesh::set_subdivide_height);
ClassDB::bind_method(D_METHOD("get_subdivide_height"), &CubeMesh::get_subdivide_height);
ClassDB::bind_method(D_METHOD("set_subdivide_depth", "divisions"), &CubeMesh::set_subdivide_depth);
ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &CubeMesh::get_subdivide_depth);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_height", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_height", "get_subdivide_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
}
void CubeMesh::set_size(const Vector3 &p_size) {
size = p_size;
_request_update();
}
Vector3 CubeMesh::get_size() const {
return size;
}
void CubeMesh::set_subdivide_width(const int p_divisions) {
subdivide_w = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int CubeMesh::get_subdivide_width() const {
return subdivide_w;
}
void CubeMesh::set_subdivide_height(const int p_divisions) {
subdivide_h = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int CubeMesh::get_subdivide_height() const {
return subdivide_h;
}
void CubeMesh::set_subdivide_depth(const int p_divisions) {
subdivide_d = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int CubeMesh::get_subdivide_depth() const {
return subdivide_d;
}
CubeMesh::CubeMesh() {
// defaults
size = Vector3(2.0, 2.0, 2.0);
subdivide_w = 0;
subdivide_h = 0;
subdivide_d = 0;
}
/**
CylinderMesh
*/
void CylinderMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z, u, v, radius;
radius = bottom_radius > top_radius ? bottom_radius : top_radius;
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
thisrow = 0;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
v = j;
v /= (rings + 1);
radius = top_radius + ((bottom_radius - top_radius) * v);
y = height * v;
y = (height * 0.5) - y;
for (i = 0; i <= radial_segments; i++) {
u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
z = cos(u * (Math_PI * 2.0));
Vector3 p = Vector3(x * radius, y, z * radius);
points.push_back(p);
normals.push_back(Vector3(x, 0.0, z));
ADD_TANGENT(-z, 0.0, x, -1.0)
uvs.push_back(Vector2(u, v * 0.5));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
// add top
if (top_radius > 0.0) {
y = height * 0.5;
thisrow = point;
points.push_back(Vector3(0.0, y, 0.0));
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, 1.0)
uvs.push_back(Vector2(0.25, 0.75));
point++;
for (i = 0; i <= radial_segments; i++) {
float r = i;
r /= radial_segments;
x = sin(r * (Math_PI * 2.0));
z = cos(r * (Math_PI * 2.0));
u = ((x + 1.0) * 0.25);
v = 0.5 + ((z + 1.0) * 0.25);
Vector3 p = Vector3(x * top_radius, y, z * top_radius);
points.push_back(p);
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, 1.0)
uvs.push_back(Vector2(u, v));
point++;
if (i > 0) {
indices.push_back(thisrow);
indices.push_back(point - 1);
indices.push_back(point - 2);
};
};
};
// add bottom
if (bottom_radius > 0.0) {
y = height * -0.5;
thisrow = point;
points.push_back(Vector3(0.0, y, 0.0));
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0)
uvs.push_back(Vector2(0.75, 0.75));
point++;
for (i = 0; i <= radial_segments; i++) {
float r = i;
r /= radial_segments;
x = sin(r * (Math_PI * 2.0));
z = cos(r * (Math_PI * 2.0));
u = 0.5 + ((x + 1.0) * 0.25);
v = 1.0 - ((z + 1.0) * 0.25);
Vector3 p = Vector3(x * bottom_radius, y, z * bottom_radius);
points.push_back(p);
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0)
uvs.push_back(Vector2(u, v));
point++;
if (i > 0) {
indices.push_back(thisrow);
indices.push_back(point - 2);
indices.push_back(point - 1);
};
};
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void CylinderMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_top_radius", "radius"), &CylinderMesh::set_top_radius);
ClassDB::bind_method(D_METHOD("get_top_radius"), &CylinderMesh::get_top_radius);
ClassDB::bind_method(D_METHOD("set_bottom_radius", "radius"), &CylinderMesh::set_bottom_radius);
ClassDB::bind_method(D_METHOD("get_bottom_radius"), &CylinderMesh::get_bottom_radius);
ClassDB::bind_method(D_METHOD("set_height", "height"), &CylinderMesh::set_height);
ClassDB::bind_method(D_METHOD("get_height"), &CylinderMesh::get_height);
ClassDB::bind_method(D_METHOD("set_radial_segments", "segments"), &CylinderMesh::set_radial_segments);
ClassDB::bind_method(D_METHOD("get_radial_segments"), &CylinderMesh::get_radial_segments);
ClassDB::bind_method(D_METHOD("set_rings", "rings"), &CylinderMesh::set_rings);
ClassDB::bind_method(D_METHOD("get_rings"), &CylinderMesh::get_rings);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "top_radius", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_top_radius", "get_top_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "bottom_radius", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_bottom_radius", "get_bottom_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_height", "get_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
}
void CylinderMesh::set_top_radius(const float p_radius) {
top_radius = p_radius;
_request_update();
}
float CylinderMesh::get_top_radius() const {
return top_radius;
}
void CylinderMesh::set_bottom_radius(const float p_radius) {
bottom_radius = p_radius;
_request_update();
}
float CylinderMesh::get_bottom_radius() const {
return bottom_radius;
}
void CylinderMesh::set_height(const float p_height) {
height = p_height;
_request_update();
}
float CylinderMesh::get_height() const {
return height;
}
void CylinderMesh::set_radial_segments(const int p_segments) {
radial_segments = p_segments > 4 ? p_segments : 4;
_request_update();
}
int CylinderMesh::get_radial_segments() const {
return radial_segments;
}
void CylinderMesh::set_rings(const int p_rings) {
rings = p_rings > 0 ? p_rings : 0;
_request_update();
}
int CylinderMesh::get_rings() const {
return rings;
}
CylinderMesh::CylinderMesh() {
// defaults
top_radius = 1.0;
bottom_radius = 1.0;
height = 2.0;
radial_segments = 64;
rings = 4;
}
/**
PlaneMesh
*/
void PlaneMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, z;
Size2 start_pos = size * -0.5;
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
/* top + bottom */
z = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_d + 1); j++) {
x = start_pos.x;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (subdivide_w + 1.0);
v /= (subdivide_d + 1.0);
points.push_back(Vector3(-x, 0.0, -z));
normals.push_back(Vector3(0.0, 1.0, 0.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(u, v));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
x += size.x / (subdivide_w + 1.0);
};
z += size.y / (subdivide_d + 1.0);
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void PlaneMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_size", "size"), &PlaneMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &PlaneMesh::get_size);
ClassDB::bind_method(D_METHOD("set_subdivide_width", "subdivide"), &PlaneMesh::set_subdivide_width);
ClassDB::bind_method(D_METHOD("get_subdivide_width"), &PlaneMesh::get_subdivide_width);
ClassDB::bind_method(D_METHOD("set_subdivide_depth", "subdivide"), &PlaneMesh::set_subdivide_depth);
ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &PlaneMesh::get_subdivide_depth);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
}
void PlaneMesh::set_size(const Size2 &p_size) {
size = p_size;
_request_update();
}
Size2 PlaneMesh::get_size() const {
return size;
}
void PlaneMesh::set_subdivide_width(const int p_divisions) {
subdivide_w = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PlaneMesh::get_subdivide_width() const {
return subdivide_w;
}
void PlaneMesh::set_subdivide_depth(const int p_divisions) {
subdivide_d = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PlaneMesh::get_subdivide_depth() const {
return subdivide_d;
}
PlaneMesh::PlaneMesh() {
// defaults
size = Size2(2.0, 2.0);
subdivide_w = 0;
subdivide_d = 0;
}
/**
PrismMesh
*/
void PrismMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z;
float onethird = 1.0 / 3.0;
float twothirds = 2.0 / 3.0;
Vector3 start_pos = size * -0.5;
// set our bounding box
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
/* front + back */
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_h + 1); j++) {
float scale = (y - start_pos.y) / size.y;
float scaled_size_x = size.x * scale;
float start_x = start_pos.x + (1.0 - scale) * size.x * left_to_right;
float offset_front = (1.0 - scale) * onethird * left_to_right;
float offset_back = (1.0 - scale) * onethird * (1.0 - left_to_right);
x = 0.0;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
u *= scale;
/* front */
points.push_back(Vector3(start_x + x, -y, -start_pos.z)); // double negative on the Z!
normals.push_back(Vector3(0.0, 0.0, 1.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(offset_front + u, v));
point++;
/* back */
points.push_back(Vector3(start_x + scaled_size_x - x, -y, start_pos.z));
normals.push_back(Vector3(0.0, 0.0, -1.0));
ADD_TANGENT(1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + offset_back + u, v));
point++;
if (i > 0 && j == 1) {
int i2 = i * 2;
/* front */
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
/* back */
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
} else if (i > 0 && j > 0) {
int i2 = i * 2;
/* front */
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
/* back */
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
x += scale * size.x / (subdivide_w + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
/* left + right */
Vector3 normal_left, normal_right;
normal_left = Vector3(-size.y, size.x * left_to_right, 0.0);
normal_right = Vector3(size.y, size.x * left_to_right, 0.0);
normal_left.normalize();
normal_right.normalize();
y = start_pos.y;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_h + 1); j++) {
float left, right;
float scale = (y - start_pos.y) / size.y;
left = start_pos.x + (size.x * (1.0 - scale) * left_to_right);
right = left + (size.x * scale);
z = start_pos.z;
for (i = 0; i <= (subdivide_d + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_d + 1.0));
v /= (2.0 * (subdivide_h + 1.0));
/* right */
points.push_back(Vector3(right, -y, -z));
normals.push_back(normal_right);
ADD_TANGENT(0.0, 0.0, 1.0, -1.0);
uvs.push_back(Vector2(onethird + u, v));
point++;
/* left */
points.push_back(Vector3(left, -y, z));
normals.push_back(normal_left);
ADD_TANGENT(0.0, 0.0, -1.0, -1.0);
uvs.push_back(Vector2(u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
int i2 = i * 2;
/* right */
indices.push_back(prevrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2 - 2);
indices.push_back(prevrow + i2);
indices.push_back(thisrow + i2);
indices.push_back(thisrow + i2 - 2);
/* left */
indices.push_back(prevrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
indices.push_back(prevrow + i2 + 1);
indices.push_back(thisrow + i2 + 1);
indices.push_back(thisrow + i2 - 1);
};
z += size.z / (subdivide_d + 1.0);
};
y += size.y / (subdivide_h + 1.0);
prevrow = thisrow;
thisrow = point;
};
/* bottom */
z = start_pos.z;
thisrow = point;
prevrow = 0;
for (j = 0; j <= (subdivide_d + 1); j++) {
x = start_pos.x;
for (i = 0; i <= (subdivide_w + 1); i++) {
float u = i;
float v = j;
u /= (3.0 * (subdivide_w + 1.0));
v /= (2.0 * (subdivide_d + 1.0));
/* bottom */
points.push_back(Vector3(x, start_pos.y, -z));
normals.push_back(Vector3(0.0, -1.0, 0.0));
ADD_TANGENT(-1.0, 0.0, 0.0, -1.0);
uvs.push_back(Vector2(twothirds + u, 0.5 + v));
point++;
if (i > 0 && j > 0) {
/* bottom */
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
x += size.x / (subdivide_w + 1.0);
};
z += size.z / (subdivide_d + 1.0);
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void PrismMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_left_to_right", "left_to_right"), &PrismMesh::set_left_to_right);
ClassDB::bind_method(D_METHOD("get_left_to_right"), &PrismMesh::get_left_to_right);
ClassDB::bind_method(D_METHOD("set_size", "size"), &PrismMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &PrismMesh::get_size);
ClassDB::bind_method(D_METHOD("set_subdivide_width", "segments"), &PrismMesh::set_subdivide_width);
ClassDB::bind_method(D_METHOD("get_subdivide_width"), &PrismMesh::get_subdivide_width);
ClassDB::bind_method(D_METHOD("set_subdivide_height", "segments"), &PrismMesh::set_subdivide_height);
ClassDB::bind_method(D_METHOD("get_subdivide_height"), &PrismMesh::get_subdivide_height);
ClassDB::bind_method(D_METHOD("set_subdivide_depth", "segments"), &PrismMesh::set_subdivide_depth);
ClassDB::bind_method(D_METHOD("get_subdivide_depth"), &PrismMesh::get_subdivide_depth);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "left_to_right", PROPERTY_HINT_RANGE, "-2.0,2.0,0.1"), "set_left_to_right", "get_left_to_right");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_width", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_width", "get_subdivide_width");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_height", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_height", "get_subdivide_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdivide_depth", PROPERTY_HINT_RANGE, "0,100,1"), "set_subdivide_depth", "get_subdivide_depth");
}
void PrismMesh::set_left_to_right(const float p_left_to_right) {
left_to_right = p_left_to_right;
_request_update();
}
float PrismMesh::get_left_to_right() const {
return left_to_right;
}
void PrismMesh::set_size(const Vector3 &p_size) {
size = p_size;
_request_update();
}
Vector3 PrismMesh::get_size() const {
return size;
}
void PrismMesh::set_subdivide_width(const int p_divisions) {
subdivide_w = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PrismMesh::get_subdivide_width() const {
return subdivide_w;
}
void PrismMesh::set_subdivide_height(const int p_divisions) {
subdivide_h = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PrismMesh::get_subdivide_height() const {
return subdivide_h;
}
void PrismMesh::set_subdivide_depth(const int p_divisions) {
subdivide_d = p_divisions > 0 ? p_divisions : 0;
_request_update();
}
int PrismMesh::get_subdivide_depth() const {
return subdivide_d;
}
PrismMesh::PrismMesh() {
// defaults
left_to_right = 0.5;
size = Vector3(2.0, 2.0, 2.0);
subdivide_w = 0;
subdivide_h = 0;
subdivide_d = 0;
}
/**
QuadMesh
*/
void QuadMesh::_create_mesh_array(Array &p_arr) const {
PoolVector<Vector3> faces;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
faces.resize(4);
normals.resize(4);
tangents.resize(4 * 4);
uvs.resize(4);
Vector2 _size = Vector2(size.x / 2.0f, size.y / 2.0f);
Vector3 quad_faces[4] = {
Vector3(-_size.x, -_size.y, 0),
Vector3(-_size.x, _size.y, 0),
Vector3(_size.x, _size.y, 0),
Vector3(_size.x, -_size.y, 0),
};
for (int i = 0; i < 4; i++) {
faces.set(i, quad_faces[i]);
normals.set(i, Vector3(0, 0, 1));
tangents.set(i * 4 + 0, 1.0);
tangents.set(i * 4 + 1, 0.0);
tangents.set(i * 4 + 2, 0.0);
tangents.set(i * 4 + 3, 1.0);
static const Vector2 quad_uv[4] = {
Vector2(0, 1),
Vector2(0, 0),
Vector2(1, 0),
Vector2(1, 1),
};
uvs.set(i, quad_uv[i]);
}
p_arr[VS::ARRAY_VERTEX] = faces;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
};
void QuadMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_size", "size"), &QuadMesh::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &QuadMesh::get_size);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "size"), "set_size", "get_size");
}
QuadMesh::QuadMesh() {
primitive_type = PRIMITIVE_TRIANGLE_FAN;
size = Size2(1.0, 1.0);
}
void QuadMesh::set_size(const Size2 &p_size) {
size = p_size;
_request_update();
}
Size2 QuadMesh::get_size() const {
return size;
}
/**
SphereMesh
*/
void SphereMesh::_create_mesh_array(Array &p_arr) const {
int i, j, prevrow, thisrow, point;
float x, y, z;
// set our bounding box
PoolVector<Vector3> points;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector2> uvs;
PoolVector<int> indices;
point = 0;
#define ADD_TANGENT(m_x, m_y, m_z, m_d) \
tangents.push_back(m_x); \
tangents.push_back(m_y); \
tangents.push_back(m_z); \
tangents.push_back(m_d);
thisrow = 0;
prevrow = 0;
for (j = 0; j <= (rings + 1); j++) {
float v = j;
float w;
v /= (rings + 1);
w = sin(Math_PI * v);
y = height * (is_hemisphere ? 1.0 : 0.5) * cos(Math_PI * v);
for (i = 0; i <= radial_segments; i++) {
float u = i;
u /= radial_segments;
x = sin(u * (Math_PI * 2.0));
z = cos(u * (Math_PI * 2.0));
if (is_hemisphere && y < 0.0) {
points.push_back(Vector3(x * radius * w, 0.0, z * radius * w));
normals.push_back(Vector3(0.0, -1.0, 0.0));
} else {
Vector3 p = Vector3(x * radius * w, y, z * radius * w);
points.push_back(p);
normals.push_back(p.normalized());
};
ADD_TANGENT(-z, 0.0, x, -1.0)
uvs.push_back(Vector2(u, v));
point++;
if (i > 0 && j > 0) {
indices.push_back(prevrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i - 1);
indices.push_back(prevrow + i);
indices.push_back(thisrow + i);
indices.push_back(thisrow + i - 1);
};
};
prevrow = thisrow;
thisrow = point;
};
p_arr[VS::ARRAY_VERTEX] = points;
p_arr[VS::ARRAY_NORMAL] = normals;
p_arr[VS::ARRAY_TANGENT] = tangents;
p_arr[VS::ARRAY_TEX_UV] = uvs;
p_arr[VS::ARRAY_INDEX] = indices;
}
void SphereMesh::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_radius", "radius"), &SphereMesh::set_radius);
ClassDB::bind_method(D_METHOD("get_radius"), &SphereMesh::get_radius);
ClassDB::bind_method(D_METHOD("set_height", "height"), &SphereMesh::set_height);
ClassDB::bind_method(D_METHOD("get_height"), &SphereMesh::get_height);
ClassDB::bind_method(D_METHOD("set_radial_segments", "radial_segments"), &SphereMesh::set_radial_segments);
ClassDB::bind_method(D_METHOD("get_radial_segments"), &SphereMesh::get_radial_segments);
ClassDB::bind_method(D_METHOD("set_rings", "rings"), &SphereMesh::set_rings);
ClassDB::bind_method(D_METHOD("get_rings"), &SphereMesh::get_rings);
ClassDB::bind_method(D_METHOD("set_is_hemisphere", "is_hemisphere"), &SphereMesh::set_is_hemisphere);
ClassDB::bind_method(D_METHOD("get_is_hemisphere"), &SphereMesh::get_is_hemisphere);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "radius", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_radius", "get_radius");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_RANGE, "0.001,100.0,0.001"), "set_height", "get_height");
ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "is_hemisphere"), "set_is_hemisphere", "get_is_hemisphere");
}
void SphereMesh::set_radius(const float p_radius) {
radius = p_radius;
_request_update();
}
float SphereMesh::get_radius() const {
return radius;
}
void SphereMesh::set_height(const float p_height) {
height = p_height;
_request_update();
}
float SphereMesh::get_height() const {
return height;
}
void SphereMesh::set_radial_segments(const int p_radial_segments) {
radial_segments = p_radial_segments > 4 ? p_radial_segments : 4;
_request_update();
}
int SphereMesh::get_radial_segments() const {
return radial_segments;
}
void SphereMesh::set_rings(const int p_rings) {
rings = p_rings > 1 ? p_rings : 1;
_request_update();
}
int SphereMesh::get_rings() const {
return rings;
}
void SphereMesh::set_is_hemisphere(const bool p_is_hemisphere) {
is_hemisphere = p_is_hemisphere;
_request_update();
}
bool SphereMesh::get_is_hemisphere() const {
return is_hemisphere;
}
SphereMesh::SphereMesh() {
// defaults
radius = 1.0;
height = 2.0;
radial_segments = 64;
rings = 32;
is_hemisphere = false;
}
|
/*=========================================================================
Program: DICOM for VTK
Copyright (c) 2012-2015 David Gobbi
All rights reserved.
See Copyright.txt or http://dgobbi.github.io/bsd3.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkDICOMDirectory.h"
#include "vtkDICOMFile.h"
#include "vtkDICOMFileDirectory.h"
#include "vtkDICOMFilePath.h"
#include "vtkDICOMItem.h"
#include "vtkDICOMMetaData.h"
#include "vtkDICOMSequence.h"
#include "vtkDICOMParser.h"
#include "vtkDICOMUtilities.h"
#include "vtkDICOMVR.h"
#include <vtkObjectFactory.h>
#include <vtkSmartPointer.h>
#include <vtkStringArray.h>
#include <vtkIntArray.h>
#include <vtkErrorCode.h>
#include <vtkCommand.h>
#include <vtkUnsignedShortArray.h>
#include <vtkSQLiteDatabase.h>
#include <vtkSQLQuery.h>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include <utility>
#include <ctype.h>
#include <stdlib.h>
vtkStandardNewMacro(vtkDICOMDirectory);
//----------------------------------------------------------------------------
// Simple structs to hold directory information.
struct vtkDICOMDirectory::SeriesItem
{
vtkDICOMItem Record;
vtkSmartPointer<vtkStringArray> Files;
vtkSmartPointer<vtkDICOMMetaData> Meta;
};
struct vtkDICOMDirectory::StudyItem
{
vtkDICOMItem Record;
vtkDICOMItem PatientRecord;
int FirstSeries;
int LastSeries;
};
struct vtkDICOMDirectory::PatientItem
{
vtkDICOMItem Record;
vtkSmartPointer<vtkIntArray> Studies;
};
class vtkDICOMDirectory::SeriesVector
: public std::vector<vtkDICOMDirectory::SeriesItem>
{};
class vtkDICOMDirectory::StudyVector
: public std::vector<vtkDICOMDirectory::StudyItem>
{};
class vtkDICOMDirectory::PatientVector
: public std::vector<vtkDICOMDirectory::PatientItem>
{};
class vtkDICOMDirectory::VisitedVector
: public std::vector<std::string>
{};
//----------------------------------------------------------------------------
// Information used to sort DICOM files.
struct vtkDICOMDirectory::FileInfo
{
unsigned int InstanceNumber;
const char *FileName;
vtkDICOMItem ImageRecord;
};
struct vtkDICOMDirectory::SeriesInfo
{
// -- PATIENT --
vtkDICOMItem PatientRecord;
vtkDICOMValue PatientName;
vtkDICOMValue PatientID;
// -- STUDY --
vtkDICOMItem StudyRecord;
vtkDICOMValue StudyDate;
vtkDICOMValue StudyTime;
vtkDICOMValue StudyUID;
// -- SERIES --
vtkDICOMItem SeriesRecord;
vtkDICOMValue SeriesUID;
unsigned int SeriesNumber;
std::vector<FileInfo> Files;
bool QueryMatched;
};
bool vtkDICOMDirectory::CompareInstance(
const FileInfo &fi1, const FileInfo &fi2)
{
return (fi1.InstanceNumber < fi2.InstanceNumber);
}
//----------------------------------------------------------------------------
// A temporary container class for use with stl algorithms
class vtkDICOMDirectory::SeriesInfoList
: public std::list<vtkDICOMDirectory::SeriesInfo>
{};
//----------------------------------------------------------------------------
vtkDICOMDirectory::vtkDICOMDirectory()
{
this->DirectoryName = 0;
this->InputFileNames = 0;
this->FilePattern = 0;
this->Series = new SeriesVector;
this->Studies = new StudyVector;
this->Patients = new PatientVector;
this->Visited = new VisitedVector;
this->FileSetID = 0;
this->InternalFileName = 0;
this->RequirePixelData = 1;
this->FollowSymlinks = 1;
this->ShowHidden = 1;
this->ScanDepth = 1;
this->Query = 0;
this->FindLevel = vtkDICOMDirectory::IMAGE;
this->UsingOsirixDatabase = false;
}
//----------------------------------------------------------------------------
vtkDICOMDirectory::~vtkDICOMDirectory()
{
if (this->InputFileNames)
{
this->InputFileNames->Delete();
}
delete [] this->DirectoryName;
delete [] this->FilePattern;
delete [] this->InternalFileName;
delete this->Series;
delete this->Studies;
delete this->Patients;
delete this->Visited;
delete [] this->FileSetID;
delete this->Query;
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
const char *inputDirectory = this->GetDirectoryName();
os << indent << "DirectoryName: "
<< (inputDirectory ? inputDirectory : "(NULL)") << "\n";
os << indent << "FilePattern: "
<< (inputDirectory ? inputDirectory : "(NULL)") << "\n";
os << indent << "FileNames: " << this->InputFileNames << "\n";
os << indent << "ScanDepth: " << this->ScanDepth << "\n";
os << indent << "FindLevel: "
<< (this->FindLevel == vtkDICOMDirectory::IMAGE ?
"IMAGE\n" : "SERIES\n");
os << indent << "RequirePixelData: "
<< (this->RequirePixelData ? "On\n" : "Off\n");
os << indent << "FollowSymlinks: "
<< (this->FollowSymlinks ? "On\n" : "Off\n");
os << indent << "NumberOfSeries: " << this->GetNumberOfSeries() << "\n";
os << indent << "NumberOfStudies: " << this->GetNumberOfStudies() << "\n";
os << indent << "NumberOfPatients: " << this->GetNumberOfPatients() << "\n";
os << indent << "FileSetID: "
<< (this->FileSetID ? this->FileSetID : "(NULL)") << "\n";
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetDirectoryName(const char *name)
{
if (name == this->DirectoryName ||
(name && this->DirectoryName &&
strcmp(name, this->DirectoryName) == 0))
{
return;
}
delete [] this->DirectoryName;
this->DirectoryName = 0;
if (name)
{
char *cp = new char[strlen(name) + 1];
strcpy(cp, name);
this->DirectoryName = cp;
}
this->Modified();
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetFilePattern(const char *name)
{
if (name == this->FilePattern ||
(name && this->FilePattern &&
strcmp(name, this->FilePattern) == 0))
{
return;
}
delete [] this->FilePattern;
this->FilePattern = 0;
if (name)
{
char *cp = new char[strlen(name) + 1];
strcpy(cp, name);
this->FilePattern = cp;
}
this->Modified();
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetInputFileNames(vtkStringArray *sa)
{
if (sa != this->InputFileNames)
{
if (this->InputFileNames)
{
this->InputFileNames->Delete();
}
if (sa)
{
sa->Register(this);
}
this->InputFileNames = sa;
this->Modified();
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetFindQuery(const vtkDICOMItem& item)
{
if (this->Query != &item)
{
delete this->Query;
this->Query = 0;
if (!item.IsEmpty())
{
this->Query = new vtkDICOMItem;
*(this->Query) = item;
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetFindLevel(int level)
{
if (level < vtkDICOMDirectory::SERIES)
{
level = vtkDICOMDirectory::SERIES;
}
if (level > vtkDICOMDirectory::IMAGE)
{
level = vtkDICOMDirectory::IMAGE;
}
if (level != this->FindLevel)
{
this->FindLevel = level;
this->Modified();
}
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetNumberOfSeries()
{
return static_cast<int>(this->Series->size());
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetSeriesRecord(int series)
{
return (*this->Series)[series].Record;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetNumberOfStudies()
{
return static_cast<int>(this->Studies->size());
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetStudyRecord(int study)
{
return (*this->Studies)[study].Record;
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetPatientRecordForStudy(int study)
{
return (*this->Studies)[study].PatientRecord;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetFirstSeriesForStudy(int study)
{
return (*this->Studies)[study].FirstSeries;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetLastSeriesForStudy(int study)
{
return (*this->Studies)[study].LastSeries;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetNumberOfPatients()
{
return static_cast<int>(this->Patients->size());
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetPatientRecord(int patient)
{
return (*this->Patients)[patient].Record;
}
//----------------------------------------------------------------------------
vtkIntArray *vtkDICOMDirectory::GetStudiesForPatient(int patient)
{
return (*this->Patients)[patient].Studies;
}
//----------------------------------------------------------------------------
vtkStringArray *vtkDICOMDirectory::GetFileNamesForSeries(int i)
{
return (*this->Series)[i].Files;
}
//----------------------------------------------------------------------------
vtkDICOMMetaData *vtkDICOMDirectory::GetMetaDataForSeries(int i)
{
return (*this->Series)[i].Meta;
}
//----------------------------------------------------------------------------
// The following code does loose matching to accomodate the way that Osirix
// modifies some attributes before storing them in its database
namespace {
// Perform cleanup of a string according to Osirix rules.
std::string OsirixCleanString(const std::string& text)
{
std::string s;
size_t l = text.length();
if (l > 0)
{
char space = '\0';
for (size_t i = 0; i < l; i++)
{
char c = text[i];
switch (c)
{
case ',':
case '^':
c = '\0';
space = ' ';
break;
case '/':
c = '-';
break;
case '\r':
case '\n':
c = '\0';
break;
case '\"':
c = '\'';
break;
case ' ':
c = '\0';
space = ' ';
break;
}
if (c)
{
if (space)
{
s.push_back(space);
space = '\0';
}
s.push_back(c);
}
}
}
return s;
}
// Loose matching for checking against Osirix database
bool MatchesOsirixDatabase(
vtkDICOMTag tag, const vtkDICOMValue& u, const vtkDICOMValue& v)
{
bool needsCleanCompare = false;
unsigned short g = tag.GetGroup();
if (u.GetNumberOfValues() > 0 && v.GetNumberOfValues() > 0 &&
(g == 0x0008 || g == 0x0010))
{
const DC::EnumType tagsToClean[] = {
DC::StudyDescription,
DC::SeriesDescription,
DC::PatientName,
DC::InstitutionName,
DC::ReferringPhysicianName,
DC::PerformingPhysicianName,
DC::ItemDelimitationItem
};
for (int i = 0; tagsToClean[i] != DC::ItemDelimitationItem; i++)
{
needsCleanCompare |= (tag == tagsToClean[i]);
}
}
bool matched = false;
if (needsCleanCompare)
{
vtkDICOMValue uclean(
u.GetVR(), vtkDICOMCharacterSet::ISO_IR_192,
OsirixCleanString(u.AsUTF8String()));
vtkDICOMValue vclean(
v.GetVR(), vtkDICOMCharacterSet::ISO_IR_192,
OsirixCleanString(v.AsUTF8String()));
matched = uclean.Matches(vclean);
}
else
{
matched = u.Matches(v);
}
return matched;
}
}
//----------------------------------------------------------------------------
bool vtkDICOMDirectory::MatchesQuery(
const vtkDICOMItem& record, vtkDICOMItem& results)
{
bool matched = true;
if (this->Query)
{
vtkDICOMDataElementIterator iter;
for (iter = record.Begin(); iter != record.End(); ++iter)
{
vtkDICOMTag tag = iter->GetTag();
if (tag != DC::SpecificCharacterSet && tag.GetGroup() != 0x0004)
{
const vtkDICOMValue& v = this->Query->GetAttributeValue(tag);
if (v.IsValid())
{
const vtkDICOMValue& u = iter->GetValue();
if (this->UsingOsirixDatabase)
{
matched = MatchesOsirixDatabase(tag, u, v);
}
else
{
matched = u.Matches(v);
}
if (matched)
{
results.SetAttributeValue(tag, u);
}
else
{
break;
}
}
}
}
}
return matched;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::MatchesImageQuery(
const vtkDICOMItem& record, const vtkDICOMItem& results)
{
bool fullyMatched = true;
bool misMatched = false;
if (this->Query)
{
vtkDICOMDataElementIterator iter;
for (iter = this->Query->Begin(); iter != this->Query->End(); ++iter)
{
vtkDICOMTag tag = iter->GetTag();
const vtkDICOMValue& v = iter->GetValue();
if (v.GetVR() == vtkDICOMVR::SQ)
{
if (v.GetNumberOfValues() > 0)
{
fullyMatched = false;
break;
}
}
else if (tag != DC::SpecificCharacterSet && tag.GetGroup() != 0x0004)
{
if (v.GetVL() > 0)
{
if (!results.GetAttributeValue(tag).IsValid())
{
const vtkDICOMValue& u = record.GetAttributeValue(tag);
if (!u.IsValid())
{
fullyMatched = false;
}
else if (!u.Matches(v))
{
misMatched = true;
break;
}
}
}
}
}
}
int r = 1;
if (fullyMatched)
{
r = 0;
}
if (misMatched)
{
r = -1;
}
return r;
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::AddSeriesWithQuery(
int patient, int study, vtkStringArray *files,
const vtkDICOMItem& patientRecord,
const vtkDICOMItem& studyRecord,
const vtkDICOMItem& seriesRecord,
const vtkDICOMItem *imageRecords[])
{
if (this->Query == 0)
{
this->AddSeriesFileNames(
patient, study, files,
patientRecord, studyRecord, seriesRecord, imageRecords);
return;
}
// To store results of querying the patient, study, series records
vtkDICOMItem results;
if (this->MatchesQuery(patientRecord, results) &&
this->MatchesQuery(studyRecord, results) &&
this->MatchesQuery(seriesRecord, results))
{
// Have we checked all the attributes in the query?
bool fullyMatched = true;
vtkDICOMDataElementIterator iter;
for (iter = this->Query->Begin(); iter != this->Query->End(); ++iter)
{
vtkDICOMTag tag = iter->GetTag();
const vtkDICOMValue& v = iter->GetValue();
if (v.GetVR() == vtkDICOMVR::SQ)
{
if (v.GetNumberOfValues() > 0)
{
fullyMatched = false;
break;
}
}
else if (tag != DC::SpecificCharacterSet && tag.GetGroup() != 0x0004)
{
if (v.GetVL() > 0 &&
!results.GetAttributeValue(tag).IsValid())
{
fullyMatched = false;
break;
}
}
}
if (fullyMatched)
{
// All query attributes have been matched!
this->AddSeriesFileNames(
patient, study, files,
patientRecord, studyRecord, seriesRecord, imageRecords);
return;
}
// Need to query against the actual files
const vtkDICOMItem **usedImageRecords = imageRecords;
std::vector<const vtkDICOMItem *> newImageRecords;
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkSmartPointer<vtkDICOMParser> parser =
vtkSmartPointer<vtkDICOMParser>::New();
parser->AddObserver(
vtkCommand::ErrorEvent, this, &vtkDICOMDirectory::RelayError);
parser->SetMetaData(meta);
parser->SetQueryItem(*this->Query);
vtkSmartPointer<vtkStringArray> a =
vtkSmartPointer<vtkStringArray>::New();
vtkIdType n = files->GetNumberOfValues();
// Only check the first file unless image-level query
if (n > 0 && this->FindLevel < vtkDICOMDirectory::IMAGE)
{
n = 1;
}
for (vtkIdType i = 0; i < n; i++)
{
const std::string& fileName = files->GetValue(i);
bool matched = false;
int r = this->MatchesImageQuery(*imageRecords[i], results);
if (r == 0)
{
// All remaining queries were matched by image record
matched = true;
}
else if (r > 0)
{
// Read the file metadata
meta->Initialize();
this->SetInternalFileName(fileName.c_str());
parser->SetFileName(fileName.c_str());
parser->Update();
if (!parser->GetPixelDataFound())
{
if (!this->ErrorCode)
{
this->ErrorCode = parser->GetErrorCode();
}
if (this->ErrorCode || this->RequirePixelData)
{
continue;
}
}
matched = parser->GetQueryMatched();
}
if (matched)
{
if (this->FindLevel < vtkDICOMDirectory::IMAGE)
{
// Add all the files.
a = files;
}
else
{
// Add the matched file.
a->InsertNextValue(fileName);
newImageRecords.push_back(imageRecords[i]);
usedImageRecords = &newImageRecords[0];
}
}
}
if (a->GetNumberOfValues() > 0)
{
this->AddSeriesFileNames(
patient, study, a,
patientRecord, studyRecord, seriesRecord, usedImageRecords);
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::AddSeriesFileNames(
int patient, int study, vtkStringArray *files,
const vtkDICOMItem& patientRecord,
const vtkDICOMItem& studyRecord,
const vtkDICOMItem& seriesRecord,
const vtkDICOMItem *imageRecords[])
{
int m = static_cast<int>(this->Patients->size());
int n = static_cast<int>(this->Studies->size());
int series = static_cast<int>(this->Series->size());
if (study == n)
{
this->Studies->push_back(StudyItem());
StudyItem& item = this->Studies->back();
item.Record = studyRecord;
item.PatientRecord = patientRecord;
item.FirstSeries = series;
item.LastSeries = series;
}
else if (n < 0 || study != n-1)
{
vtkErrorMacro("AddSeriesFileNames: non-monotonically increasing study")
return;
}
if (patient == m)
{
this->Patients->push_back(PatientItem());
PatientItem& item = this->Patients->back();
item.Record = patientRecord;
item.Studies = vtkSmartPointer<vtkIntArray>::New();
item.Studies->InsertNextValue(study);
}
else if (m >= 0 && patient <= m-1)
{
PatientItem& item = (*this->Patients)[patient];
vtkIdType nn = item.Studies->GetMaxId() + 1;
vtkIdType ii = 0;
for (; ii < nn; ii++)
{
if (study == item.Studies->GetValue(ii))
{
break;
}
}
if (ii == nn)
{
item.Studies->InsertNextValue(study);
}
}
else
{
vtkErrorMacro("AddSeriesFileNames: non-monotonically increasing patient")
return;
}
// Check for files that are duplicate instances
int ni = static_cast<int>(files->GetNumberOfValues());
std::vector<int> duplicate(ni);
std::vector<int> seriesLength;
seriesLength.push_back(0);
int numberOfDuplicates = 0;
for (int ii = 0; ii < ni; ii++)
{
const vtkDICOMValue& uid =
imageRecords[ii]->GetAttributeValue(DC::SOPInstanceUID);
int count = 0;
if (uid.GetVL() > 0)
{
for (int jj = 0; jj < ii; jj++)
{
if (imageRecords[jj]->GetAttributeValue(DC::SOPInstanceUID) == uid)
{
count++;
}
}
}
duplicate[ii] = count;
if (count > numberOfDuplicates)
{
numberOfDuplicates = count;
seriesLength.push_back(0);
}
seriesLength[count]++;
}
// Add each duplicate as a separate series
for (int kk = 0; kk <= numberOfDuplicates; kk++)
{
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
meta->SetNumberOfInstances(seriesLength[kk]);
this->CopyRecord(meta, &patientRecord, -1);
this->CopyRecord(meta, &studyRecord, -1);
this->CopyRecord(meta, &seriesRecord, -1);
vtkSmartPointer<vtkStringArray> newfiles;
if (numberOfDuplicates > 0)
{
newfiles = vtkSmartPointer<vtkStringArray>::New();
newfiles->SetNumberOfValues(seriesLength[kk]);
}
else
{
newfiles = files;
}
int jj = 0;
for (int ii = 0; ii < ni; ii++)
{
if (duplicate[ii] == kk)
{
this->CopyRecord(meta, imageRecords[ii], jj);
if (numberOfDuplicates > 0)
{
newfiles->SetValue(jj, files->GetValue(ii));
}
}
}
(*this->Studies)[study].LastSeries = series++;
this->Series->push_back(SeriesItem());
SeriesItem& item = this->Series->back();
item.Record = seriesRecord;
item.Files = newfiles;
item.Meta = meta;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::CopyRecord(
vtkDICOMMetaData *meta, const vtkDICOMItem *item, int instance)
{
vtkDICOMDataElementIterator iter = item->Begin();
vtkDICOMDataElementIterator iterEnd = item->End();
for (; iter != iterEnd; ++iter)
{
vtkDICOMTag tag = iter->GetTag();
if (tag.GetGroup() == 0x0004)
{
// DICOMDIR-specific tags
if (tag == DC::ReferencedSOPClassUIDInFile)
{
tag = DC::SOPClassUID;
}
else if (tag == DC::ReferencedSOPInstanceUIDInFile)
{
tag = DC::SOPInstanceUID;
}
else if (tag == DC::ReferencedTransferSyntaxUIDInFile)
{
tag = DC::TransferSyntaxUID;
}
else
{
continue;
}
}
if (instance >= 0)
{
meta->SetAttributeValue(instance, tag, iter->GetValue());
}
else
{
meta->SetAttributeValue(tag, iter->GetValue());
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillImageRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SOPClassUID,
DC::SOPInstanceUID,
DC::InstanceNumber,
DC::Rows,
DC::Columns,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillSeriesRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SpecificCharacterSet,
DC::SeriesDate,
DC::SeriesTime,
DC::Modality,
DC::SeriesDescription,
DC::SeriesInstanceUID,
DC::SeriesNumber,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillStudyRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SpecificCharacterSet,
DC::StudyDate,
DC::StudyTime,
DC::ReferringPhysicianName,
DC::PatientAge,
DC::StudyInstanceUID,
DC::StudyID,
DC::AccessionNumber,
DC::StudyDescription,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillPatientRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SpecificCharacterSet,
DC::PatientName,
DC::PatientID,
DC::PatientBirthDate,
DC::PatientSex,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SortFiles(vtkStringArray *input)
{
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkSmartPointer<vtkDICOMMetaData> query =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkSmartPointer<vtkDICOMParser> parser =
vtkSmartPointer<vtkDICOMParser>::New();
parser->AddObserver(
vtkCommand::ErrorEvent, this, &vtkDICOMDirectory::RelayError);
parser->SetMetaData(meta);
// these are the attributes that must be part of the query
static const DC::EnumType requiredElements[] = {
// basic required information
DC::SpecificCharacterSet, // 1C
// image-level information
DC::SOPClassUID, // 1
DC::SOPInstanceUID, // 1
DC::InstanceNumber, // 1
DC::Rows, // 3
DC::Columns, // 3
// series-level information
DC::SeriesDate, // 3
DC::SeriesTime, // 3
DC::Modality, // 1
DC::SeriesDescription, // 3
DC::SeriesInstanceUID, // 1
DC::SeriesNumber, // 1
// study-level information
DC::StudyDate, // 1
DC::StudyTime, // 1
DC::ReferringPhysicianName, // 3
DC::PatientAge, // 3
DC::StudyInstanceUID, // 1
DC::StudyID, // 1
DC::AccessionNumber, // 2
DC::StudyDescription, // 2
// patient-level information
DC::PatientName, // 2
DC::PatientID, // 1
DC::PatientBirthDate, // 3
DC::PatientSex, // 3
// delimiter to mark end of list
DC::ItemDelimitationItem
};
for (const DC::EnumType *tagPtr = requiredElements;
*tagPtr != DC::ItemDelimitationItem;
++tagPtr)
{
vtkDICOMVR vr = query->FindDictVR(0, *tagPtr);
query->SetAttributeValue(*tagPtr, vtkDICOMValue(vr));
}
if (this->Query)
{
// add elements that the user requested for the query
vtkDICOMDataElementIterator iter = this->Query->Begin();
vtkDICOMDataElementIterator iterEnd = this->Query->End();
while (iter != iterEnd)
{
query->SetAttributeValue(iter->GetTag(), iter->GetValue());
++iter;
}
// use a buffer size equal to one disk block
parser->SetBufferSize(4096);
}
parser->SetQuery(query);
SeriesInfoList sortedFiles;
SeriesInfoList::iterator li;
vtkIdType numberOfStrings = input->GetNumberOfValues();
for (vtkIdType j = 0; j < numberOfStrings; j++)
{
const std::string& fileName = input->GetValue(j);
// Skip anything that does not look like a DICOM file.
if (!vtkDICOMUtilities::IsDICOMFile(fileName.c_str()))
{
int code = vtkDICOMFile::Access(fileName.c_str(), vtkDICOMFile::In);
if (code == vtkDICOMFile::FileNotFound)
{
vtkWarningMacro("File does not exist: " << fileName.c_str());
}
else if (code == vtkDICOMFile::AccessDenied)
{
vtkWarningMacro("File permission denied: " << fileName.c_str());
}
else if (code == vtkDICOMFile::FileIsDirectory)
{
vtkWarningMacro("File is a directory: " << fileName.c_str());
}
else if (code == vtkDICOMFile::ImpossiblePath)
{
vtkWarningMacro("Bad file path: " << fileName.c_str());
}
else if (code != 0)
{
vtkWarningMacro("Unknown file error: " << fileName.c_str());
}
continue;
}
// Read the file metadata
meta->Initialize();
this->SetInternalFileName(fileName.c_str());
parser->SetFileName(fileName.c_str());
parser->Update();
if (!parser->GetPixelDataFound())
{
if (!this->ErrorCode)
{
this->ErrorCode = parser->GetErrorCode();
}
if (this->ErrorCode || this->RequirePixelData)
{
continue;
}
}
// Check for abort and update progress at 1% intervals
if (!this->AbortExecute)
{
double progress = (j + 1.0)/numberOfStrings;
if (progress == 1.0 || progress > this->GetProgress() + 0.01)
{
progress = static_cast<int>(progress*100.0)/100.0;
this->UpdateProgress(progress);
}
}
if (this->AbortExecute)
{
return;
}
// Check if the file matches the query
bool queryMatched = (!this->Query || parser->GetQueryMatched());
if (!queryMatched && this->FindLevel == vtkDICOMDirectory::IMAGE)
{
continue;
}
// Insert the file into the sorted list
FileInfo fileInfo;
fileInfo.InstanceNumber =
meta->GetAttributeValue(DC::InstanceNumber).AsUnsignedInt();
fileInfo.FileName = fileName.c_str(); // stored in input StringArray
const vtkDICOMValue& patientNameValue =
meta->GetAttributeValue(DC::PatientName);
const vtkDICOMValue& patientIDValue =
meta->GetAttributeValue(DC::PatientID);
const vtkDICOMValue& studyDateValue =
meta->GetAttributeValue(DC::StudyDate);
const vtkDICOMValue& studyTimeValue =
meta->GetAttributeValue(DC::StudyTime);
const vtkDICOMValue& studyUIDValue =
meta->GetAttributeValue(DC::StudyInstanceUID);
const vtkDICOMValue& seriesUIDValue =
meta->GetAttributeValue(DC::SeriesInstanceUID);
unsigned int seriesNumber =
meta->GetAttributeValue(DC::SeriesNumber).AsUnsignedInt();
const char *patientName = patientNameValue.GetCharData();
const char *patientID = patientIDValue.GetCharData();
const char *studyDate = studyDateValue.GetCharData();
const char *studyTime = studyTimeValue.GetCharData();
const char *studyUID = studyUIDValue.GetCharData();
const char *seriesUID = seriesUIDValue.GetCharData();
patientName = (patientName ? patientName : "");
patientID = (patientID ? patientID : "");
bool foundSeries = false;
for (li = sortedFiles.begin(); li != sortedFiles.end(); ++li)
{
// Compare patient, then study, then series.
const char *patientName2 = li->PatientName.GetCharData();
patientName2 = (patientName2 ? patientName2 : "");
const char *patientID2 = li->PatientID.GetCharData();
patientID2 = (patientID2 ? patientID2 : "");
int c = strcmp(patientID2, patientID);
if (c != 0 || patientID[0] == '\0')
{
// Use ID to identify patient, but use name to sort.
int c2 = strcmp(patientName2, patientName);
c = (c2 == 0 ? c : c2);
}
if (c == 0)
{
c = vtkDICOMUtilities::CompareUIDs(
studyUID, li->StudyUID.GetCharData());
if (c != 0 || studyUID == 0)
{
// Use UID to identify study, but use date to sort.
int c2 = 0;
const char *studyDate2 = li->StudyDate.GetCharData();
if (studyDate && studyDate2)
{
c2 = strcmp(studyDate2, studyDate);
if (c2 == 0)
{
const char *studyTime2 = li->StudyTime.GetCharData();
if (studyTime2 && studyTime)
{
c2 = strcmp(studyTime, studyTime2);
}
}
}
c = (c2 == 0 ? c : c2);
}
if (c == 0)
{
c = vtkDICOMUtilities::CompareUIDs(
seriesUID, li->SeriesUID.GetCharData());
if (c != 0 || seriesUID == 0)
{
// Use UID to identify series, but use series number to sort.
int c2 = li->SeriesNumber - seriesNumber;
c = (c2 == 0 ? c : c2);
}
}
}
if (c == 0 && seriesUID != 0)
{
std::vector<FileInfo>::iterator pos =
li->Files.insert(
std::upper_bound(li->Files.begin(), li->Files.end(), fileInfo,
CompareInstance), fileInfo);
this->FillImageRecord(&pos->ImageRecord, meta);
li->QueryMatched |= queryMatched;
foundSeries = true;
break;
}
else if (c >= 0)
{
break;
}
}
if (!foundSeries)
{
li = sortedFiles.insert(li, SeriesInfo());
li->PatientName = patientNameValue;
li->PatientID = patientIDValue;
li->StudyDate = studyDateValue;
li->StudyUID = studyUIDValue;
li->SeriesUID = seriesUIDValue;
li->SeriesNumber = seriesNumber;
li->Files.push_back(fileInfo);
li->QueryMatched = queryMatched;
this->FillPatientRecord(&li->PatientRecord, meta);
this->FillStudyRecord(&li->StudyRecord, meta);
this->FillSeriesRecord(&li->SeriesRecord, meta);
this->FillImageRecord(&li->Files.back().ImageRecord, meta);
}
}
// Visit each series and call AddSeriesFileNames
int patientCount = this->GetNumberOfPatients();
int studyCount = this->GetNumberOfStudies();
vtkDICOMValue lastStudyUID;
vtkDICOMValue lastPatientID;
for (li = sortedFiles.begin(); li != sortedFiles.end(); ++li)
{
SeriesInfo &v = *li;
if (!v.QueryMatched) { continue; }
// Is this a new patient or a new study?
if (!lastPatientID.IsValid() || v.PatientID != lastPatientID)
{
lastPatientID = v.PatientID;
patientCount++;
lastStudyUID = v.StudyUID;
studyCount++;
}
else if (!lastStudyUID.IsValid() || v.StudyUID != lastStudyUID)
{
lastStudyUID = v.StudyUID;
studyCount++;
}
vtkSmartPointer<vtkStringArray> sa =
vtkSmartPointer<vtkStringArray>::New();
vtkIdType n = static_cast<vtkIdType>(v.Files.size());
sa->SetNumberOfValues(n);
std::vector<const vtkDICOMItem *> imageRecords(n);
for (vtkIdType i = 0; i < n; i++)
{
sa->SetValue(i, v.Files[i].FileName);
imageRecords[i] = &v.Files[i].ImageRecord;
}
this->AddSeriesFileNames(
patientCount-1, studyCount-1, sa,
v.PatientRecord, v.StudyRecord, v.SeriesRecord, &imageRecords[0]);
}
}
//----------------------------------------------------------------------------
namespace {
// Trivial structs needed by ProcessOsirixDatabase
struct StudyRow { vtkVariant col[12]; };
struct SeriesRow { vtkVariant col[8]; };
struct ImageRow { vtkVariant col[7]; };
// Decompress a SOPInstanceUID from an Osirix database
std::string DecompressUID(const std::string& s)
{
char uid[64];
size_t n = s.length();
size_t m = 0;
for (size_t i = 0; i < n && i < 32; i++)
{
unsigned char c = s[i];
c >>= 4;
if (c == 0) { break; }
c += ('0' - 1);
if (c > '9') { c = '.'; }
uid[m++] = c;
c = s[i];
c &= 0x0f;
if (c == 0) { break; }
c += ('0' - 1);
if (c > '9') { c = '.'; }
uid[m++] = c;
}
return std::string(uid, m);
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::ProcessOsirixDatabase(const char *fname)
{
// Open the database
vtkSmartPointer<vtkSQLiteDatabase> dbase =
vtkSmartPointer<vtkSQLiteDatabase>::New();
dbase->SetDatabaseFileName(fname);
if (!dbase->Open("", vtkSQLiteDatabase::USE_EXISTING))
{
vtkErrorMacro("Unable to open database file " << fname);
return;
}
// Make sure this is an OsiriX database file.
vtkStringArray *tables = dbase->GetTables();
int count = 0;
for (vtkIdType i = 0; i < tables->GetNumberOfValues(); i++)
{
std::string s = tables->GetValue(i);
count += (s == "ZSTUDY" || s == "ZSERIES" || s == "ZIMAGE");
}
if (count != 3)
{
return;
}
// Create the path to DATABASE.noindex, where .dcm files are stored
vtkDICOMFilePath path(fname);
path.PopBack();
path.PushBack("DATABASE.noindex");
vtkSQLQuery *q = dbase->GetQueryInstance();
// Indices to columns in the study table
enum {
ST_PK, ST_DATE, ST_DATEOFBIRTH, ST_MODALITY, ST_NAME,
ST_INSTITUTIONNAME, ST_STUDYNAME, ST_ID, ST_STUDYINSTANCEUID,
ST_ACCESSIONNUMBER, ST_PATIENTSEX, ST_PATIENTID, ST_NCOLS
};
// Indices to columns in the series table
enum {
SE_PK, SE_ID, SE_DATE, SE_SERIESSOPCLASSUID, SE_MODALITY,
SE_NAME, SE_SERIESDICOMUID, SE_SERIESDESCRIPTION, SE_NCOLS
};
// Indices to columns in the image table
enum {
IM_INSTANCENUMBER, IM_FRAMEID, IM_PATHNUMBER, IM_PATHSTRING,
IM_COMPRESSEDSOPINSTANCEUID, IM_STOREDHEIGHT, IM_STOREDWIDTH, IM_NCOLS
};
// These vectors will hold the tables
std::vector<StudyRow> studyTable;
std::vector<SeriesRow> seriesTable;
std::vector<ImageRow> imageTable;
// Acquire a shared lock while reading the three tables, to ensure that
// the three tables are consistent with each other.
q->BeginTransaction();
// Read the study table
if (!q->SetQuery("select Z_PK,ZDATE,ZDATEOFBIRTH,ZMODALITY,ZNAME,"
"ZINSTITUTIONNAME,ZSTUDYNAME,ZID,ZSTUDYINSTANCEUID,"
"ZACCESSIONNUMBER,ZPATIENTSEX,ZPATIENTID from ZSTUDY"
" order by ZDATE") ||
!q->Execute())
{
vtkErrorMacro("Badly structured ZSTUDY table: " << fname);
q->CommitTransaction();
q->Delete();
return;
}
while (q->NextRow())
{
studyTable.push_back(StudyRow());
StudyRow *row = &studyTable.back();
for (int k = 0; k < ST_NCOLS; k++)
{
row->col[k] = q->DataValue(k);
}
}
// Read the series table
if (!q->SetQuery("select Z_PK,ZID,ZDATE,ZSERIESSOPCLASSUID,"
"ZMODALITY,ZNAME,ZSERIESDICOMUID,ZSERIESDESCRIPTION,"
"ZSTUDY from ZSERIES order by ZSTUDY,ZID") ||
!q->Execute())
{
vtkErrorMacro("Badly structured ZSERIES table: " << fname);
q->CommitTransaction();
q->Delete();
return;
}
std::vector<vtkTypeInt64> zseriesVec;
while (q->NextRow())
{
seriesTable.push_back(SeriesRow());
SeriesRow *row = &seriesTable.back();
for (int k = 0; k < SE_NCOLS; k++)
{
row->col[k] = q->DataValue(k);
}
zseriesVec.push_back(q->DataValue(SE_NCOLS).ToTypeInt64());
}
// Read the image table
if (!q->SetQuery("select ZINSTANCENUMBER,ZFRAMEID,ZPATHNUMBER,"
"ZPATHSTRING,ZCOMPRESSEDSOPINSTANCEUID,"
"ZSTOREDHEIGHT,ZSTOREDWIDTH,ZSERIES"
" from ZIMAGE order by"
" ZSERIES,ZINSTANCENUMBER") ||
!q->Execute())
{
vtkErrorMacro("Badly structured IMAGE table: " << fname);
q->CommitTransaction();
q->Delete();
return;
}
std::vector<vtkTypeInt64> zimageVec;
while (q->NextRow())
{
imageTable.push_back(ImageRow());
ImageRow *row = &imageTable.back();
for (int k = 0; k < IM_NCOLS; k++)
{
row->col[k] = q->DataValue(k);
}
zimageVec.push_back(q->DataValue(IM_NCOLS).ToTypeInt64());
}
// Close the database and delete it by setting the smart pointer to NULL.
// Calling CommitTransaction doesn't write anything, because only SELECT
// has been used. Instead, it just releases the shared lock.
q->CommitTransaction();
q->Delete();
dbase = NULL;
// To track progress, count number of images processed.
size_t imageCounter = 0;
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
// Go through all of the studies
for (std::vector<StudyRow>::iterator st = studyTable.begin();
st != studyTable.end(); ++st)
{
vtkDICOMItem patientItem;
vtkDICOMItem studyItem;
vtkTypeInt64 zstudy = st->col[ST_PK].ToTypeInt64();
std::string name = st->col[ST_NAME].ToString();
std::string patientID = st->col[ST_PATIENTID].ToString();
// Seconds between our time base and database time base
const double timediff = 978307200.0;
double studySeconds = st->col[ST_DATE].ToDouble();
double birthSeconds = st->col[ST_DATEOFBIRTH].ToDouble();
std::string studyDT = vtkDICOMUtilities::GenerateDateTime(
static_cast<long long>((studySeconds + timediff)*1e6), NULL);
std::string birthDT = vtkDICOMUtilities::GenerateDateTime(
static_cast<long long>((birthSeconds + timediff)*1e6), NULL);
patientItem.SetAttributeValue(
DC::SpecificCharacterSet, vtkDICOMCharacterSet::ISO_IR_192);
patientItem.SetAttributeValue(DC::PatientName, name);
patientItem.SetAttributeValue(DC::PatientID, patientID);
patientItem.SetAttributeValue(DC::PatientBirthDate, birthDT.substr(0, 8));
patientItem.SetAttributeValue(
DC::PatientSex, st->col[ST_PATIENTSEX].ToString());
studyItem.SetAttributeValue(
DC::SpecificCharacterSet, vtkDICOMCharacterSet::ISO_IR_192);
studyItem.SetAttributeValue(
DC::StudyDescription, st->col[ST_STUDYNAME].ToString());
studyItem.SetAttributeValue(
DC::StudyID, st->col[ST_ID].ToString());
studyItem.SetAttributeValue(
DC::StudyInstanceUID, st->col[ST_STUDYINSTANCEUID].ToString());
studyItem.SetAttributeValue(
DC::InstitutionName, st->col[ST_INSTITUTIONNAME].ToString());
studyItem.SetAttributeValue(
DC::AccessionNumber, st->col[ST_ACCESSIONNUMBER].ToString());
studyItem.SetAttributeValue(DC::StudyDate, studyDT.substr(0,8));
studyItem.SetAttributeValue(DC::StudyTime, studyDT.substr(8,13));
int studyIdx = this->GetNumberOfStudies();
int patientIdx;
int firstUnusedPatientIdx = this->GetNumberOfPatients();
// Loop until corrent patientIdx is found
for (patientIdx = 0; patientIdx < firstUnusedPatientIdx; patientIdx++)
{
const vtkDICOMItem& pitem = this->GetPatientRecord(patientIdx);
const vtkDICOMValue& vid = pitem.GetAttributeValue(DC::PatientID);
if (vid.IsValid() && vid.GetVL() > 0)
{
if (patientID.length() > 0 && vid.Matches(patientID.c_str()))
{
break;
}
}
else // Use PatientName if PatientID is empty
{
const vtkDICOMValue& vna = pitem.GetAttributeValue(DC::PatientName);
if (vna.IsValid() && vna.GetVL() > 0)
{
if (name.length() > 0 && vna.Matches(name.c_str()))
{
break;
}
}
}
}
// Search for the first series in the study
std::vector<vtkTypeInt64>::iterator zseriesVecIter =
std::lower_bound(zseriesVec.begin(), zseriesVec.end(), zstudy);
size_t seIdx = std::distance(zseriesVec.begin(), zseriesVecIter);
// Go through all of the series in the study
for (std::vector<SeriesRow>::iterator se = seriesTable.begin() + seIdx;
se != seriesTable.end(); ++se)
{
// Break when we find a series that isn't part of the study
if (*zseriesVecIter > zstudy)
{
break;
}
++zseriesVecIter;
vtkDICOMItem seriesItem;
vtkTypeInt64 zseries = se->col[SE_PK].ToTypeInt64();
double seriesSeconds = se->col[SE_DATE].ToDouble();
std::string seriesDT = vtkDICOMUtilities::GenerateDateTime(
static_cast<long long>((seriesSeconds + timediff)*1e6), NULL);
vtkDICOMValue sopClassUID(
vtkDICOMVR::UI, se->col[SE_SERIESSOPCLASSUID].ToString());
std::string seriesUID = se->col[SE_SERIESDICOMUID].ToString();
// Remove any text before the UID
size_t k = 0;
while (k < seriesUID.length() &&
(seriesUID[k] <= '0' || seriesUID[k] >= '9'))
{
k++;
}
if (k > 0)
{
seriesUID = seriesUID.substr(k, seriesUID.length()-k);
}
seriesItem.SetAttributeValue(
DC::SpecificCharacterSet, vtkDICOMCharacterSet::ISO_IR_192);
seriesItem.SetAttributeValue(
DC::SeriesDescription, se->col[SE_NAME].ToString());
seriesItem.SetAttributeValue(
DC::ProtocolName, se->col[SE_SERIESDESCRIPTION].ToString());
seriesItem.SetAttributeValue(
DC::SeriesNumber, se->col[SE_ID].ToString());
seriesItem.SetAttributeValue(DC::SeriesInstanceUID, seriesUID);
seriesItem.SetAttributeValue(DC::SeriesDate, seriesDT.substr(0,8));
seriesItem.SetAttributeValue(DC::SeriesTime, seriesDT.substr(8,13));
seriesItem.SetAttributeValue(
DC::Modality, se->col[SE_MODALITY].ToString());
vtkSmartPointer<vtkStringArray> fileNames =
vtkSmartPointer<vtkStringArray>::New();
vtkDICOMSequence imageRecordSequence;
std::string lastpath;
// Search for the first image in the series
std::vector<vtkTypeInt64>::iterator zimageVecIter =
std::lower_bound(zimageVec.begin(), zimageVec.end(), zseries);
size_t imIdx = std::distance(zimageVec.begin(), zimageVecIter);
// Go through all of the images in the series
for (std::vector<ImageRow>::iterator im = imageTable.begin() + imIdx;
im != imageTable.end(); ++im)
{
// Break when we find a series that isn't part of the study
if (*zimageVecIter > zseries)
{
break;
}
++zimageVecIter;
std::string fpath = im->col[IM_PATHSTRING].ToString();
if (fpath.length() == 0)
{
// no PATHSTRING, so use PATHNUMBER instead
vtkTypeInt64 fnum = im->col[IM_PATHNUMBER].ToTypeInt64();
vtkTypeInt64 dnum = (fnum/10000 + 1)*10000;
vtkVariant fv(fnum);
vtkVariant dv(dnum);
path.PushBack(dv.ToString());
path.PushBack(fv.ToString() + ".dcm");
fpath = path.AsString();
path.PopBack();
path.PopBack();
}
else if (fpath[0] != '/')
{
// PATHSTRING is a local path, not an absolute path
vtkTypeInt64 fnum = atol(fpath.c_str());
vtkTypeInt64 dnum = (fnum/10000 + 1)*10000;
vtkVariant dv(dnum);
path.PushBack(dv.ToString());
path.PushBack(fpath);
fpath = path.AsString();
path.PopBack();
path.PopBack();
}
if (fpath != lastpath)
{
// Add the path to the list of filenames
vtkDICOMItem imageRecord;
imageRecord.SetAttributeValue(DC::SOPClassUID, sopClassUID);
imageRecord.SetAttributeValue(
DC::SOPInstanceUID,
DecompressUID(im->col[IM_COMPRESSEDSOPINSTANCEUID].ToString()));
imageRecord.SetAttributeValue(
DC::InstanceNumber, im->col[IM_INSTANCENUMBER].ToString());
imageRecord.SetAttributeValue(
DC::Rows, im->col[IM_STOREDHEIGHT].ToInt());
imageRecord.SetAttributeValue(
DC::Columns, im->col[IM_STOREDWIDTH].ToInt());
imageRecordSequence.AddItem(imageRecord);
fileNames->InsertNextValue(fpath);
lastpath = fpath;
}
// Increment the progress counter.
imageCounter++;
}
// Add the series if it passes the query
size_t n = imageRecordSequence.GetNumberOfItems();
if (n > 0)
{
const vtkDICOMItem *data = imageRecordSequence.GetSequenceData();
std::vector<const vtkDICOMItem *> imageRecords(n);
for (size_t i = 0; i < n; i++)
{
imageRecords[i] = &data[i];
}
// Set a flag to indicate that loose matching is needed, because
// the Osirix database "cleans" certain attribute value strings
this->UsingOsirixDatabase = true;
this->AddSeriesWithQuery(
patientIdx, studyIdx, fileNames,
patientItem, studyItem, seriesItem, &imageRecords[0]);
this->UsingOsirixDatabase = false;
}
// Check for abort and update progress at 1% intervals
if (!this->AbortExecute)
{
double progress = (imageCounter + 1.0)/imageTable.size();
if (progress == 1.0 || progress > this->GetProgress() + 0.01)
{
progress = static_cast<int>(progress*100.0)/100.0;
this->UpdateProgress(progress);
}
}
if (this->AbortExecute)
{
return;
}
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::ProcessDirectoryFile(
const char *dirname, vtkDICOMMetaData *meta)
{
// Get the ID of this file set (informative only).
if (meta->HasAttribute(DC::FileSetID))
{
std::string fileSetID = meta->GetAttributeValue(DC::FileSetID).AsString();
this->FileSetID = new char[fileSetID.length() + 1];
strcpy(this->FileSetID, fileSetID.c_str());
}
// Get the directory as a sequence.
const vtkDICOMValue& seq =
meta->GetAttributeValue(DC::DirectoryRecordSequence);
unsigned int n = seq.GetNumberOfValues();
const vtkDICOMItem *items = seq.GetSequenceData();
// The DICOMDIR uses byte offsets to identify items in the sequence.
std::map<unsigned int, unsigned int> offsetToIndexMap;
for (unsigned int i = 0; i < n; i++)
{
offsetToIndexMap[items[i].GetByteOffset()] = i;
}
// Get the first entry.
unsigned int offset =
meta->GetAttributeValue(
DC::OffsetOfTheFirstDirectoryRecordOfTheRootDirectoryEntity)
.AsUnsignedInt();
// This check is just for insurance.
if (offset == 0 && n > 0)
{
offset = items[0].GetByteOffset();
}
// To track progress, count number of items processed.
unsigned int itemCounter = 0;
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
// A stack to track the directory level.
std::vector<std::pair<unsigned int, std::string> > offsetStack;
int patientIdx = this->GetNumberOfPatients();
int studyIdx = this->GetNumberOfStudies();
unsigned int patientItem = 0;
unsigned int studyItem = 0;
unsigned int seriesItem = 0;
// List of filenames for the current series.
vtkSmartPointer<vtkStringArray> fileNames =
vtkSmartPointer<vtkStringArray>::New();
std::vector<const vtkDICOMItem *> imageRecords;
// The entry type that is currently being processed.
std::string entryType;
// Go through the directory, using the "next" and "child" pointers.
while (offset != 0)
{
unsigned int offsetOfChild = 0;
std::map<unsigned int, unsigned int>::iterator iter =
offsetToIndexMap.find(offset);
offset = 0;
if (iter != offsetToIndexMap.end() && iter->second != 0xffffffffu)
{
// Get the item index, mark the item as used.
unsigned int j = iter->second;
iter->second = 0xffffffffu;
offset = items[j].GetAttributeValue(
DC::OffsetOfTheNextDirectoryRecord).AsUnsignedInt();
offsetOfChild = items[j].GetAttributeValue(
DC::OffsetOfReferencedLowerLevelDirectoryEntity).AsUnsignedInt();
entryType = items[j].GetAttributeValue(
DC::DirectoryRecordType).AsString();
if (entryType == "PATIENT")
{
patientItem = j;
}
else if (entryType == "STUDY")
{
studyItem = j;
}
else if (entryType == "SERIES")
{
seriesItem = j;
}
else if (entryType == "IMAGE" || !this->RequirePixelData)
{
const vtkDICOMValue& fileID =
items[j].GetAttributeValue(DC::ReferencedFileID);
if (fileID.IsValid())
{
unsigned int m = fileID.GetNumberOfValues();
if (m > 0)
{
vtkDICOMFilePath path(dirname);
for (unsigned int k = 0; k < m; k++)
{
path.PushBack(fileID.GetString(k));
}
vtkIdType ki = fileNames->InsertNextValue(path.AsString());
imageRecords.push_back(&items[j]);
// sort the files by instance number, they will almost always
// already be in order so we use a simple algorithm
int inst = items[j].GetAttributeValue(DC::InstanceNumber).AsInt();
while (ki > 0)
{
const vtkDICOMItem *prev = imageRecords[--ki];
int inst2 = prev->GetAttributeValue(DC::InstanceNumber).AsInt();
if (inst < inst2)
{
std::string s = fileNames->GetValue(ki + 1);
fileNames->SetValue(ki + 1, fileNames->GetValue(ki));
fileNames->SetValue(ki, s);
std::swap(imageRecords[ki], imageRecords[ki + 1]);
}
else
{
// sorting is finished!
break;
}
}
}
}
}
}
if (offsetOfChild != 0)
{
// Go up one directory level.
offsetStack.push_back(std::make_pair(offset, entryType));
offset = offsetOfChild;
}
else
{
// Pop the stack until the next offset is not zero.
while (offset == 0 && offsetStack.size() > 0)
{
// Go down one directory level.
offset = offsetStack.back().first;
entryType = offsetStack.back().second;
offsetStack.pop_back();
if (entryType == "PATIENT")
{
// Get current max patient index plus one
patientIdx = this->GetNumberOfPatients();
}
else if (entryType == "STUDY")
{
// Get current max study index plus one
studyIdx = this->GetNumberOfStudies();
}
else if (entryType == "SERIES")
{
if (!imageRecords.empty())
{
// Add the series if it passes the query
this->AddSeriesWithQuery(
patientIdx, studyIdx, fileNames,
items[patientItem], items[studyItem], items[seriesItem],
&imageRecords[0]);
fileNames = vtkSmartPointer<vtkStringArray>::New();
imageRecords.clear();
}
}
}
}
// Check for abort and update progress at 1% intervals
if (!this->AbortExecute)
{
double progress = (itemCounter + 1.0)/n;
if (progress == 1.0 || progress > this->GetProgress() + 0.01)
{
progress = static_cast<int>(progress*100.0)/100.0;
this->UpdateProgress(progress);
}
}
if (this->AbortExecute)
{
return;
}
++itemCounter;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::ProcessDirectory(
const char *dirname, int depth, vtkStringArray *files)
{
// Check if the directory has been visited yet. This avoids infinite
// recursion when following circular links.
std::string realname = vtkDICOMFilePath(dirname).GetRealPath();
std::vector<std::string>::iterator viter =
std::lower_bound(this->Visited->begin(), this->Visited->end(), realname);
if (viter == this->Visited->end() || *viter != realname)
{
// Add this directory to the "visited" list.
this->Visited->insert(viter, realname);
}
else
{
// This directory has already been visited.
return;
}
// Find the path to the directory.
vtkDICOMFilePath path(dirname);
if (depth == this->ScanDepth)
{
// Build the path to the DICOMDIR file.
path.PushBack("DICOMDIR");
std::string dicomdir = path.AsString();
path.PopBack();
// Check to see if the DICOMDIR file exists.
if (vtkDICOMFile::Access(dicomdir.c_str(), vtkDICOMFile::In) == 0)
{
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkDICOMParser *parser = vtkDICOMParser::New();
parser->AddObserver(
vtkCommand::ErrorEvent, this, &vtkDICOMDirectory::RelayError);
parser->SetMetaData(meta);
this->SetInternalFileName(dicomdir.c_str());
parser->SetFileName(dicomdir.c_str());
parser->Update();
unsigned long errorCode = parser->GetErrorCode();
parser->Delete();
if (errorCode && depth == 0)
{
// Only fail if depth is zero. Otherwise, we can ignore the
// DICOMDIR and look for the DICOM files directly.
this->ErrorCode = errorCode;
return;
}
else if (errorCode == 0)
{
// Process the DICOMDIR file.
this->ProcessDirectoryFile(dirname, meta);
return;
}
}
}
// If depth is zero, recursion is complete.
if (depth <= 0)
{
return;
}
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
vtkDICOMFileDirectory d(dirname);
if (d.GetError() != 0)
{
// Only fail at the initial depth.
if (depth == this->ScanDepth)
{
vtkErrorMacro(<< "Could not read directory " << dirname);
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
return;
}
}
int n = d.GetNumberOfFiles();
for (int i = 0; i < n; i++)
{
const char *fname = d.GetFile(i);
if ((fname[0] != '.' || (fname[1] != '\0' &&
(fname[1] != '.' || fname[2] != '\0'))) &&
strcmp(fname, "DICOMDIR") != 0)
{
path.PushBack(fname);
std::string fileString = path.AsString();
path.PopBack();
if (!this->FollowSymlinks && d.IsSymlink(i))
{
// Do nothing unless FollowSymlinks is On
}
#ifdef _WIN32
else if (!this->ShowHidden && d.IsHidden(i))
#else
else if (!this->ShowHidden && (d.IsHidden(i) || fname[0] == '.'))
#endif
{
// Do nothing for hidden files unless ShowHidden is On
// (on Linux and OS X, consider "." files to be hidden)
}
else if (d.IsDirectory(i))
{
if (depth > 1)
{
this->ProcessDirectory(fileString.c_str(), depth-1, files);
}
}
else if (this->FilePattern == 0 || this->FilePattern[0] == '\0' ||
vtkDICOMUtilities::PatternMatches(
this->FilePattern, fileString.c_str()))
{
files->InsertNextValue(fileString);
}
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::Execute()
{
// Clear the output
this->Series->clear();
this->Studies->clear();
this->Patients->clear();
this->Visited->clear();
delete [] this->FileSetID;
this->FileSetID = 0;
this->ErrorCode = 0;
this->InvokeEvent(vtkCommand::StartEvent);
vtkSmartPointer<vtkStringArray> files =
vtkSmartPointer<vtkStringArray>::New();
if (this->InputFileNames)
{
for (vtkIdType i = 0; i < this->InputFileNames->GetNumberOfValues(); i++)
{
const std::string& fname = this->InputFileNames->GetValue(i);
int code = vtkDICOMFile::Access(fname.c_str(), vtkDICOMFile::In);
if (code == vtkDICOMFile::FileIsDirectory)
{
this->ProcessDirectory(fname.c_str(), this->ScanDepth, files);
}
else if (code == vtkDICOMFile::FileNotFound)
{
this->ErrorCode = vtkErrorCode::FileNotFoundError;
vtkErrorMacro("File or directory not found: " << fname.c_str());
return;
}
else if (code == vtkDICOMFile::AccessDenied)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Permission denied: " << fname.c_str());
return;
}
else if (code == vtkDICOMFile::ImpossiblePath)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Bad file path: " << fname.c_str());
return;
}
else if (code != 0)
{
this->ErrorCode = vtkErrorCode::UnknownError;
vtkErrorMacro("Unknown file error: " << fname.c_str());
return;
}
else if (vtkDICOMUtilities::PatternMatches("*.sql", fname.c_str()))
{
this->ProcessOsirixDatabase(fname.c_str());
}
else if (this->FilePattern == 0 || this->FilePattern[0] == '\0' ||
vtkDICOMUtilities::PatternMatches(
this->FilePattern, fname.c_str()))
{
files->InsertNextValue(fname);
}
}
}
else
{
if (this->DirectoryName == 0)
{
// No directory is a valid input. Return an empty output.
return;
}
int code = vtkDICOMFile::Access(this->DirectoryName, vtkDICOMFile::In);
if (code == vtkDICOMFile::FileIsDirectory)
{
this->ProcessDirectory(this->DirectoryName, this->ScanDepth, files);
}
else if (code == vtkDICOMFile::FileNotFound)
{
this->ErrorCode = vtkErrorCode::FileNotFoundError;
vtkErrorMacro("Directory not found: " << this->DirectoryName);
return;
}
else if (code == vtkDICOMFile::AccessDenied)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Permission denied: " << this->DirectoryName);
return;
}
else if (code == vtkDICOMFile::ImpossiblePath)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Bad file path: " << this->DirectoryName);
return;
}
else if (code != 0)
{
this->ErrorCode = vtkErrorCode::UnknownError;
vtkErrorMacro("Unknown error: " << this->DirectoryName);
return;
}
else
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Found a file, not a directory: " << this->DirectoryName);
return;
}
}
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
if (files->GetNumberOfValues() > 0)
{
this->SortFiles(files);
}
this->InvokeEvent(vtkCommand::EndEvent);
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::Update(int)
{
this->AbortExecute = 0;
if (this->GetMTime() > this->UpdateTime.GetMTime())
{
this->Execute();
this->UpdateTime.Modified();
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetInternalFileName(const char *name)
{
if (this->InternalFileName == NULL && name == NULL)
{
return;
}
if (this->InternalFileName != 0 && name != 0 &&
strcmp(this->InternalFileName, name) == 0)
{
return;
}
if (this->InternalFileName)
{
delete [] this->InternalFileName;
}
if (name)
{
size_t n = strlen(name) + 1;
char *cp1 = new char[n];
const char *cp2 = (name);
this->InternalFileName = cp1;
do { *cp1++ = *cp2++; } while (--n);
}
else
{
this->InternalFileName = 0;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::RelayError(vtkObject *o, unsigned long e, void *data)
{
if (e == vtkCommand::ErrorEvent)
{
vtkDICOMParser *parser = vtkDICOMParser::SafeDownCast(o);
if (parser)
{
this->SetErrorCode(parser->GetErrorCode());
this->SetInternalFileName(parser->GetFileName());
}
vtkErrorMacro(<< static_cast<char *>(data));
}
else
{
this->InvokeEvent(e, data);
}
}
Avoid calling GetAttributeValue in an O(n^2) loop.
/*=========================================================================
Program: DICOM for VTK
Copyright (c) 2012-2015 David Gobbi
All rights reserved.
See Copyright.txt or http://dgobbi.github.io/bsd3.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkDICOMDirectory.h"
#include "vtkDICOMFile.h"
#include "vtkDICOMFileDirectory.h"
#include "vtkDICOMFilePath.h"
#include "vtkDICOMItem.h"
#include "vtkDICOMMetaData.h"
#include "vtkDICOMSequence.h"
#include "vtkDICOMParser.h"
#include "vtkDICOMUtilities.h"
#include "vtkDICOMVR.h"
#include <vtkObjectFactory.h>
#include <vtkSmartPointer.h>
#include <vtkStringArray.h>
#include <vtkIntArray.h>
#include <vtkErrorCode.h>
#include <vtkCommand.h>
#include <vtkUnsignedShortArray.h>
#include <vtkSQLiteDatabase.h>
#include <vtkSQLQuery.h>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <algorithm>
#include <utility>
#include <ctype.h>
#include <stdlib.h>
vtkStandardNewMacro(vtkDICOMDirectory);
//----------------------------------------------------------------------------
// Simple structs to hold directory information.
struct vtkDICOMDirectory::SeriesItem
{
vtkDICOMItem Record;
vtkSmartPointer<vtkStringArray> Files;
vtkSmartPointer<vtkDICOMMetaData> Meta;
};
struct vtkDICOMDirectory::StudyItem
{
vtkDICOMItem Record;
vtkDICOMItem PatientRecord;
int FirstSeries;
int LastSeries;
};
struct vtkDICOMDirectory::PatientItem
{
vtkDICOMItem Record;
vtkSmartPointer<vtkIntArray> Studies;
};
class vtkDICOMDirectory::SeriesVector
: public std::vector<vtkDICOMDirectory::SeriesItem>
{};
class vtkDICOMDirectory::StudyVector
: public std::vector<vtkDICOMDirectory::StudyItem>
{};
class vtkDICOMDirectory::PatientVector
: public std::vector<vtkDICOMDirectory::PatientItem>
{};
class vtkDICOMDirectory::VisitedVector
: public std::vector<std::string>
{};
//----------------------------------------------------------------------------
// Information used to sort DICOM files.
struct vtkDICOMDirectory::FileInfo
{
unsigned int InstanceNumber;
const char *FileName;
vtkDICOMItem ImageRecord;
};
struct vtkDICOMDirectory::SeriesInfo
{
// -- PATIENT --
vtkDICOMItem PatientRecord;
vtkDICOMValue PatientName;
vtkDICOMValue PatientID;
// -- STUDY --
vtkDICOMItem StudyRecord;
vtkDICOMValue StudyDate;
vtkDICOMValue StudyTime;
vtkDICOMValue StudyUID;
// -- SERIES --
vtkDICOMItem SeriesRecord;
vtkDICOMValue SeriesUID;
unsigned int SeriesNumber;
std::vector<FileInfo> Files;
bool QueryMatched;
};
bool vtkDICOMDirectory::CompareInstance(
const FileInfo &fi1, const FileInfo &fi2)
{
return (fi1.InstanceNumber < fi2.InstanceNumber);
}
//----------------------------------------------------------------------------
// A temporary container class for use with stl algorithms
class vtkDICOMDirectory::SeriesInfoList
: public std::list<vtkDICOMDirectory::SeriesInfo>
{};
//----------------------------------------------------------------------------
vtkDICOMDirectory::vtkDICOMDirectory()
{
this->DirectoryName = 0;
this->InputFileNames = 0;
this->FilePattern = 0;
this->Series = new SeriesVector;
this->Studies = new StudyVector;
this->Patients = new PatientVector;
this->Visited = new VisitedVector;
this->FileSetID = 0;
this->InternalFileName = 0;
this->RequirePixelData = 1;
this->FollowSymlinks = 1;
this->ShowHidden = 1;
this->ScanDepth = 1;
this->Query = 0;
this->FindLevel = vtkDICOMDirectory::IMAGE;
this->UsingOsirixDatabase = false;
}
//----------------------------------------------------------------------------
vtkDICOMDirectory::~vtkDICOMDirectory()
{
if (this->InputFileNames)
{
this->InputFileNames->Delete();
}
delete [] this->DirectoryName;
delete [] this->FilePattern;
delete [] this->InternalFileName;
delete this->Series;
delete this->Studies;
delete this->Patients;
delete this->Visited;
delete [] this->FileSetID;
delete this->Query;
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
const char *inputDirectory = this->GetDirectoryName();
os << indent << "DirectoryName: "
<< (inputDirectory ? inputDirectory : "(NULL)") << "\n";
os << indent << "FilePattern: "
<< (inputDirectory ? inputDirectory : "(NULL)") << "\n";
os << indent << "FileNames: " << this->InputFileNames << "\n";
os << indent << "ScanDepth: " << this->ScanDepth << "\n";
os << indent << "FindLevel: "
<< (this->FindLevel == vtkDICOMDirectory::IMAGE ?
"IMAGE\n" : "SERIES\n");
os << indent << "RequirePixelData: "
<< (this->RequirePixelData ? "On\n" : "Off\n");
os << indent << "FollowSymlinks: "
<< (this->FollowSymlinks ? "On\n" : "Off\n");
os << indent << "NumberOfSeries: " << this->GetNumberOfSeries() << "\n";
os << indent << "NumberOfStudies: " << this->GetNumberOfStudies() << "\n";
os << indent << "NumberOfPatients: " << this->GetNumberOfPatients() << "\n";
os << indent << "FileSetID: "
<< (this->FileSetID ? this->FileSetID : "(NULL)") << "\n";
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetDirectoryName(const char *name)
{
if (name == this->DirectoryName ||
(name && this->DirectoryName &&
strcmp(name, this->DirectoryName) == 0))
{
return;
}
delete [] this->DirectoryName;
this->DirectoryName = 0;
if (name)
{
char *cp = new char[strlen(name) + 1];
strcpy(cp, name);
this->DirectoryName = cp;
}
this->Modified();
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetFilePattern(const char *name)
{
if (name == this->FilePattern ||
(name && this->FilePattern &&
strcmp(name, this->FilePattern) == 0))
{
return;
}
delete [] this->FilePattern;
this->FilePattern = 0;
if (name)
{
char *cp = new char[strlen(name) + 1];
strcpy(cp, name);
this->FilePattern = cp;
}
this->Modified();
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetInputFileNames(vtkStringArray *sa)
{
if (sa != this->InputFileNames)
{
if (this->InputFileNames)
{
this->InputFileNames->Delete();
}
if (sa)
{
sa->Register(this);
}
this->InputFileNames = sa;
this->Modified();
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetFindQuery(const vtkDICOMItem& item)
{
if (this->Query != &item)
{
delete this->Query;
this->Query = 0;
if (!item.IsEmpty())
{
this->Query = new vtkDICOMItem;
*(this->Query) = item;
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetFindLevel(int level)
{
if (level < vtkDICOMDirectory::SERIES)
{
level = vtkDICOMDirectory::SERIES;
}
if (level > vtkDICOMDirectory::IMAGE)
{
level = vtkDICOMDirectory::IMAGE;
}
if (level != this->FindLevel)
{
this->FindLevel = level;
this->Modified();
}
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetNumberOfSeries()
{
return static_cast<int>(this->Series->size());
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetSeriesRecord(int series)
{
return (*this->Series)[series].Record;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetNumberOfStudies()
{
return static_cast<int>(this->Studies->size());
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetStudyRecord(int study)
{
return (*this->Studies)[study].Record;
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetPatientRecordForStudy(int study)
{
return (*this->Studies)[study].PatientRecord;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetFirstSeriesForStudy(int study)
{
return (*this->Studies)[study].FirstSeries;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetLastSeriesForStudy(int study)
{
return (*this->Studies)[study].LastSeries;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::GetNumberOfPatients()
{
return static_cast<int>(this->Patients->size());
}
//----------------------------------------------------------------------------
const vtkDICOMItem& vtkDICOMDirectory::GetPatientRecord(int patient)
{
return (*this->Patients)[patient].Record;
}
//----------------------------------------------------------------------------
vtkIntArray *vtkDICOMDirectory::GetStudiesForPatient(int patient)
{
return (*this->Patients)[patient].Studies;
}
//----------------------------------------------------------------------------
vtkStringArray *vtkDICOMDirectory::GetFileNamesForSeries(int i)
{
return (*this->Series)[i].Files;
}
//----------------------------------------------------------------------------
vtkDICOMMetaData *vtkDICOMDirectory::GetMetaDataForSeries(int i)
{
return (*this->Series)[i].Meta;
}
//----------------------------------------------------------------------------
// The following code does loose matching to accomodate the way that Osirix
// modifies some attributes before storing them in its database
namespace {
// Perform cleanup of a string according to Osirix rules.
std::string OsirixCleanString(const std::string& text)
{
std::string s;
size_t l = text.length();
if (l > 0)
{
char space = '\0';
for (size_t i = 0; i < l; i++)
{
char c = text[i];
switch (c)
{
case ',':
case '^':
c = '\0';
space = ' ';
break;
case '/':
c = '-';
break;
case '\r':
case '\n':
c = '\0';
break;
case '\"':
c = '\'';
break;
case ' ':
c = '\0';
space = ' ';
break;
}
if (c)
{
if (space)
{
s.push_back(space);
space = '\0';
}
s.push_back(c);
}
}
}
return s;
}
// Loose matching for checking against Osirix database
bool MatchesOsirixDatabase(
vtkDICOMTag tag, const vtkDICOMValue& u, const vtkDICOMValue& v)
{
bool needsCleanCompare = false;
unsigned short g = tag.GetGroup();
if (u.GetNumberOfValues() > 0 && v.GetNumberOfValues() > 0 &&
(g == 0x0008 || g == 0x0010))
{
const DC::EnumType tagsToClean[] = {
DC::StudyDescription,
DC::SeriesDescription,
DC::PatientName,
DC::InstitutionName,
DC::ReferringPhysicianName,
DC::PerformingPhysicianName,
DC::ItemDelimitationItem
};
for (int i = 0; tagsToClean[i] != DC::ItemDelimitationItem; i++)
{
needsCleanCompare |= (tag == tagsToClean[i]);
}
}
bool matched = false;
if (needsCleanCompare)
{
vtkDICOMValue uclean(
u.GetVR(), vtkDICOMCharacterSet::ISO_IR_192,
OsirixCleanString(u.AsUTF8String()));
vtkDICOMValue vclean(
v.GetVR(), vtkDICOMCharacterSet::ISO_IR_192,
OsirixCleanString(v.AsUTF8String()));
matched = uclean.Matches(vclean);
}
else
{
matched = u.Matches(v);
}
return matched;
}
}
//----------------------------------------------------------------------------
bool vtkDICOMDirectory::MatchesQuery(
const vtkDICOMItem& record, vtkDICOMItem& results)
{
bool matched = true;
if (this->Query)
{
vtkDICOMDataElementIterator iter;
for (iter = record.Begin(); iter != record.End(); ++iter)
{
vtkDICOMTag tag = iter->GetTag();
if (tag != DC::SpecificCharacterSet && tag.GetGroup() != 0x0004)
{
const vtkDICOMValue& v = this->Query->GetAttributeValue(tag);
if (v.IsValid())
{
const vtkDICOMValue& u = iter->GetValue();
if (this->UsingOsirixDatabase)
{
matched = MatchesOsirixDatabase(tag, u, v);
}
else
{
matched = u.Matches(v);
}
if (matched)
{
results.SetAttributeValue(tag, u);
}
else
{
break;
}
}
}
}
}
return matched;
}
//----------------------------------------------------------------------------
int vtkDICOMDirectory::MatchesImageQuery(
const vtkDICOMItem& record, const vtkDICOMItem& results)
{
bool fullyMatched = true;
bool misMatched = false;
if (this->Query)
{
vtkDICOMDataElementIterator iter;
for (iter = this->Query->Begin(); iter != this->Query->End(); ++iter)
{
vtkDICOMTag tag = iter->GetTag();
const vtkDICOMValue& v = iter->GetValue();
if (v.GetVR() == vtkDICOMVR::SQ)
{
if (v.GetNumberOfValues() > 0)
{
fullyMatched = false;
break;
}
}
else if (tag != DC::SpecificCharacterSet && tag.GetGroup() != 0x0004)
{
if (v.GetVL() > 0)
{
if (!results.GetAttributeValue(tag).IsValid())
{
const vtkDICOMValue& u = record.GetAttributeValue(tag);
if (!u.IsValid())
{
fullyMatched = false;
}
else if (!u.Matches(v))
{
misMatched = true;
break;
}
}
}
}
}
}
int r = 1;
if (fullyMatched)
{
r = 0;
}
if (misMatched)
{
r = -1;
}
return r;
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::AddSeriesWithQuery(
int patient, int study, vtkStringArray *files,
const vtkDICOMItem& patientRecord,
const vtkDICOMItem& studyRecord,
const vtkDICOMItem& seriesRecord,
const vtkDICOMItem *imageRecords[])
{
if (this->Query == 0)
{
this->AddSeriesFileNames(
patient, study, files,
patientRecord, studyRecord, seriesRecord, imageRecords);
return;
}
// To store results of querying the patient, study, series records
vtkDICOMItem results;
if (this->MatchesQuery(patientRecord, results) &&
this->MatchesQuery(studyRecord, results) &&
this->MatchesQuery(seriesRecord, results))
{
// Have we checked all the attributes in the query?
bool fullyMatched = true;
vtkDICOMDataElementIterator iter;
for (iter = this->Query->Begin(); iter != this->Query->End(); ++iter)
{
vtkDICOMTag tag = iter->GetTag();
const vtkDICOMValue& v = iter->GetValue();
if (v.GetVR() == vtkDICOMVR::SQ)
{
if (v.GetNumberOfValues() > 0)
{
fullyMatched = false;
break;
}
}
else if (tag != DC::SpecificCharacterSet && tag.GetGroup() != 0x0004)
{
if (v.GetVL() > 0 &&
!results.GetAttributeValue(tag).IsValid())
{
fullyMatched = false;
break;
}
}
}
if (fullyMatched)
{
// All query attributes have been matched!
this->AddSeriesFileNames(
patient, study, files,
patientRecord, studyRecord, seriesRecord, imageRecords);
return;
}
// Need to query against the actual files
const vtkDICOMItem **usedImageRecords = imageRecords;
std::vector<const vtkDICOMItem *> newImageRecords;
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkSmartPointer<vtkDICOMParser> parser =
vtkSmartPointer<vtkDICOMParser>::New();
parser->AddObserver(
vtkCommand::ErrorEvent, this, &vtkDICOMDirectory::RelayError);
parser->SetMetaData(meta);
parser->SetQueryItem(*this->Query);
vtkSmartPointer<vtkStringArray> a =
vtkSmartPointer<vtkStringArray>::New();
vtkIdType n = files->GetNumberOfValues();
// Only check the first file unless image-level query
if (n > 0 && this->FindLevel < vtkDICOMDirectory::IMAGE)
{
n = 1;
}
for (vtkIdType i = 0; i < n; i++)
{
const std::string& fileName = files->GetValue(i);
bool matched = false;
int r = this->MatchesImageQuery(*imageRecords[i], results);
if (r == 0)
{
// All remaining queries were matched by image record
matched = true;
}
else if (r > 0)
{
// Read the file metadata
meta->Initialize();
this->SetInternalFileName(fileName.c_str());
parser->SetFileName(fileName.c_str());
parser->Update();
if (!parser->GetPixelDataFound())
{
if (!this->ErrorCode)
{
this->ErrorCode = parser->GetErrorCode();
}
if (this->ErrorCode || this->RequirePixelData)
{
continue;
}
}
matched = parser->GetQueryMatched();
}
if (matched)
{
if (this->FindLevel < vtkDICOMDirectory::IMAGE)
{
// Add all the files.
a = files;
}
else
{
// Add the matched file.
a->InsertNextValue(fileName);
newImageRecords.push_back(imageRecords[i]);
usedImageRecords = &newImageRecords[0];
}
}
}
if (a->GetNumberOfValues() > 0)
{
this->AddSeriesFileNames(
patient, study, a,
patientRecord, studyRecord, seriesRecord, usedImageRecords);
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::AddSeriesFileNames(
int patient, int study, vtkStringArray *files,
const vtkDICOMItem& patientRecord,
const vtkDICOMItem& studyRecord,
const vtkDICOMItem& seriesRecord,
const vtkDICOMItem *imageRecords[])
{
int m = static_cast<int>(this->Patients->size());
int n = static_cast<int>(this->Studies->size());
int series = static_cast<int>(this->Series->size());
if (study == n)
{
this->Studies->push_back(StudyItem());
StudyItem& item = this->Studies->back();
item.Record = studyRecord;
item.PatientRecord = patientRecord;
item.FirstSeries = series;
item.LastSeries = series;
}
else if (n < 0 || study != n-1)
{
vtkErrorMacro("AddSeriesFileNames: non-monotonically increasing study")
return;
}
if (patient == m)
{
this->Patients->push_back(PatientItem());
PatientItem& item = this->Patients->back();
item.Record = patientRecord;
item.Studies = vtkSmartPointer<vtkIntArray>::New();
item.Studies->InsertNextValue(study);
}
else if (m >= 0 && patient <= m-1)
{
PatientItem& item = (*this->Patients)[patient];
vtkIdType nn = item.Studies->GetMaxId() + 1;
vtkIdType ii = 0;
for (; ii < nn; ii++)
{
if (study == item.Studies->GetValue(ii))
{
break;
}
}
if (ii == nn)
{
item.Studies->InsertNextValue(study);
}
}
else
{
vtkErrorMacro("AddSeriesFileNames: non-monotonically increasing patient")
return;
}
// Check for files that are duplicate instances
int ni = static_cast<int>(files->GetNumberOfValues());
std::vector<const vtkDICOMValue *> uids(ni);
for (int ii = 0; ii < ni; ii++)
{
uids[ii] = &imageRecords[ii]->GetAttributeValue(DC::SOPInstanceUID);
}
std::vector<int> duplicate(ni);
std::vector<int> seriesLength;
seriesLength.push_back(0);
int numberOfDuplicates = 0;
for (int ii = 0; ii < ni; ii++)
{
int count = 0;
const vtkDICOMValue *uid = uids[ii];
if (uid->GetVL() > 0)
{
for (int jj = 0; jj < ii; jj++)
{
if (*(uids[jj]) == *uid)
{
count++;
}
}
}
duplicate[ii] = count;
if (count > numberOfDuplicates)
{
numberOfDuplicates = count;
seriesLength.push_back(0);
}
seriesLength[count]++;
}
// Add each duplicate as a separate series
for (int kk = 0; kk <= numberOfDuplicates; kk++)
{
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
meta->SetNumberOfInstances(seriesLength[kk]);
this->CopyRecord(meta, &patientRecord, -1);
this->CopyRecord(meta, &studyRecord, -1);
this->CopyRecord(meta, &seriesRecord, -1);
vtkSmartPointer<vtkStringArray> newfiles;
if (numberOfDuplicates > 0)
{
newfiles = vtkSmartPointer<vtkStringArray>::New();
newfiles->SetNumberOfValues(seriesLength[kk]);
}
else
{
newfiles = files;
}
int jj = 0;
for (int ii = 0; ii < ni; ii++)
{
if (duplicate[ii] == kk)
{
this->CopyRecord(meta, imageRecords[ii], jj);
if (numberOfDuplicates > 0)
{
newfiles->SetValue(jj, files->GetValue(ii));
}
}
}
(*this->Studies)[study].LastSeries = series++;
this->Series->push_back(SeriesItem());
SeriesItem& item = this->Series->back();
item.Record = seriesRecord;
item.Files = newfiles;
item.Meta = meta;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::CopyRecord(
vtkDICOMMetaData *meta, const vtkDICOMItem *item, int instance)
{
vtkDICOMDataElementIterator iter = item->Begin();
vtkDICOMDataElementIterator iterEnd = item->End();
for (; iter != iterEnd; ++iter)
{
vtkDICOMTag tag = iter->GetTag();
if (tag.GetGroup() == 0x0004)
{
// DICOMDIR-specific tags
if (tag == DC::ReferencedSOPClassUIDInFile)
{
tag = DC::SOPClassUID;
}
else if (tag == DC::ReferencedSOPInstanceUIDInFile)
{
tag = DC::SOPInstanceUID;
}
else if (tag == DC::ReferencedTransferSyntaxUIDInFile)
{
tag = DC::TransferSyntaxUID;
}
else
{
continue;
}
}
if (instance >= 0)
{
meta->SetAttributeValue(instance, tag, iter->GetValue());
}
else
{
meta->SetAttributeValue(tag, iter->GetValue());
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillImageRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SOPClassUID,
DC::SOPInstanceUID,
DC::InstanceNumber,
DC::Rows,
DC::Columns,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillSeriesRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SpecificCharacterSet,
DC::SeriesDate,
DC::SeriesTime,
DC::Modality,
DC::SeriesDescription,
DC::SeriesInstanceUID,
DC::SeriesNumber,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillStudyRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SpecificCharacterSet,
DC::StudyDate,
DC::StudyTime,
DC::ReferringPhysicianName,
DC::PatientAge,
DC::StudyInstanceUID,
DC::StudyID,
DC::AccessionNumber,
DC::StudyDescription,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::FillPatientRecord(
vtkDICOMItem *item, vtkDICOMMetaData *meta)
{
static const DC::EnumType tags[] = {
DC::SpecificCharacterSet,
DC::PatientName,
DC::PatientID,
DC::PatientBirthDate,
DC::PatientSex,
DC::ItemDelimitationItem
};
const DC::EnumType *tag = tags;
while (*tag != DC::ItemDelimitationItem)
{
item->SetAttributeValue(*tag, meta->GetAttributeValue(*tag));
tag++;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SortFiles(vtkStringArray *input)
{
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkSmartPointer<vtkDICOMMetaData> query =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkSmartPointer<vtkDICOMParser> parser =
vtkSmartPointer<vtkDICOMParser>::New();
parser->AddObserver(
vtkCommand::ErrorEvent, this, &vtkDICOMDirectory::RelayError);
parser->SetMetaData(meta);
// these are the attributes that must be part of the query
static const DC::EnumType requiredElements[] = {
// basic required information
DC::SpecificCharacterSet, // 1C
// image-level information
DC::SOPClassUID, // 1
DC::SOPInstanceUID, // 1
DC::InstanceNumber, // 1
DC::Rows, // 3
DC::Columns, // 3
// series-level information
DC::SeriesDate, // 3
DC::SeriesTime, // 3
DC::Modality, // 1
DC::SeriesDescription, // 3
DC::SeriesInstanceUID, // 1
DC::SeriesNumber, // 1
// study-level information
DC::StudyDate, // 1
DC::StudyTime, // 1
DC::ReferringPhysicianName, // 3
DC::PatientAge, // 3
DC::StudyInstanceUID, // 1
DC::StudyID, // 1
DC::AccessionNumber, // 2
DC::StudyDescription, // 2
// patient-level information
DC::PatientName, // 2
DC::PatientID, // 1
DC::PatientBirthDate, // 3
DC::PatientSex, // 3
// delimiter to mark end of list
DC::ItemDelimitationItem
};
for (const DC::EnumType *tagPtr = requiredElements;
*tagPtr != DC::ItemDelimitationItem;
++tagPtr)
{
vtkDICOMVR vr = query->FindDictVR(0, *tagPtr);
query->SetAttributeValue(*tagPtr, vtkDICOMValue(vr));
}
if (this->Query)
{
// add elements that the user requested for the query
vtkDICOMDataElementIterator iter = this->Query->Begin();
vtkDICOMDataElementIterator iterEnd = this->Query->End();
while (iter != iterEnd)
{
query->SetAttributeValue(iter->GetTag(), iter->GetValue());
++iter;
}
// use a buffer size equal to one disk block
parser->SetBufferSize(4096);
}
parser->SetQuery(query);
SeriesInfoList sortedFiles;
SeriesInfoList::iterator li;
vtkIdType numberOfStrings = input->GetNumberOfValues();
for (vtkIdType j = 0; j < numberOfStrings; j++)
{
const std::string& fileName = input->GetValue(j);
// Skip anything that does not look like a DICOM file.
if (!vtkDICOMUtilities::IsDICOMFile(fileName.c_str()))
{
int code = vtkDICOMFile::Access(fileName.c_str(), vtkDICOMFile::In);
if (code == vtkDICOMFile::FileNotFound)
{
vtkWarningMacro("File does not exist: " << fileName.c_str());
}
else if (code == vtkDICOMFile::AccessDenied)
{
vtkWarningMacro("File permission denied: " << fileName.c_str());
}
else if (code == vtkDICOMFile::FileIsDirectory)
{
vtkWarningMacro("File is a directory: " << fileName.c_str());
}
else if (code == vtkDICOMFile::ImpossiblePath)
{
vtkWarningMacro("Bad file path: " << fileName.c_str());
}
else if (code != 0)
{
vtkWarningMacro("Unknown file error: " << fileName.c_str());
}
continue;
}
// Read the file metadata
meta->Initialize();
this->SetInternalFileName(fileName.c_str());
parser->SetFileName(fileName.c_str());
parser->Update();
if (!parser->GetPixelDataFound())
{
if (!this->ErrorCode)
{
this->ErrorCode = parser->GetErrorCode();
}
if (this->ErrorCode || this->RequirePixelData)
{
continue;
}
}
// Check for abort and update progress at 1% intervals
if (!this->AbortExecute)
{
double progress = (j + 1.0)/numberOfStrings;
if (progress == 1.0 || progress > this->GetProgress() + 0.01)
{
progress = static_cast<int>(progress*100.0)/100.0;
this->UpdateProgress(progress);
}
}
if (this->AbortExecute)
{
return;
}
// Check if the file matches the query
bool queryMatched = (!this->Query || parser->GetQueryMatched());
if (!queryMatched && this->FindLevel == vtkDICOMDirectory::IMAGE)
{
continue;
}
// Insert the file into the sorted list
FileInfo fileInfo;
fileInfo.InstanceNumber =
meta->GetAttributeValue(DC::InstanceNumber).AsUnsignedInt();
fileInfo.FileName = fileName.c_str(); // stored in input StringArray
const vtkDICOMValue& patientNameValue =
meta->GetAttributeValue(DC::PatientName);
const vtkDICOMValue& patientIDValue =
meta->GetAttributeValue(DC::PatientID);
const vtkDICOMValue& studyDateValue =
meta->GetAttributeValue(DC::StudyDate);
const vtkDICOMValue& studyTimeValue =
meta->GetAttributeValue(DC::StudyTime);
const vtkDICOMValue& studyUIDValue =
meta->GetAttributeValue(DC::StudyInstanceUID);
const vtkDICOMValue& seriesUIDValue =
meta->GetAttributeValue(DC::SeriesInstanceUID);
unsigned int seriesNumber =
meta->GetAttributeValue(DC::SeriesNumber).AsUnsignedInt();
const char *patientName = patientNameValue.GetCharData();
const char *patientID = patientIDValue.GetCharData();
const char *studyDate = studyDateValue.GetCharData();
const char *studyTime = studyTimeValue.GetCharData();
const char *studyUID = studyUIDValue.GetCharData();
const char *seriesUID = seriesUIDValue.GetCharData();
patientName = (patientName ? patientName : "");
patientID = (patientID ? patientID : "");
bool foundSeries = false;
for (li = sortedFiles.begin(); li != sortedFiles.end(); ++li)
{
// Compare patient, then study, then series.
const char *patientName2 = li->PatientName.GetCharData();
patientName2 = (patientName2 ? patientName2 : "");
const char *patientID2 = li->PatientID.GetCharData();
patientID2 = (patientID2 ? patientID2 : "");
int c = strcmp(patientID2, patientID);
if (c != 0 || patientID[0] == '\0')
{
// Use ID to identify patient, but use name to sort.
int c2 = strcmp(patientName2, patientName);
c = (c2 == 0 ? c : c2);
}
if (c == 0)
{
c = vtkDICOMUtilities::CompareUIDs(
studyUID, li->StudyUID.GetCharData());
if (c != 0 || studyUID == 0)
{
// Use UID to identify study, but use date to sort.
int c2 = 0;
const char *studyDate2 = li->StudyDate.GetCharData();
if (studyDate && studyDate2)
{
c2 = strcmp(studyDate2, studyDate);
if (c2 == 0)
{
const char *studyTime2 = li->StudyTime.GetCharData();
if (studyTime2 && studyTime)
{
c2 = strcmp(studyTime, studyTime2);
}
}
}
c = (c2 == 0 ? c : c2);
}
if (c == 0)
{
c = vtkDICOMUtilities::CompareUIDs(
seriesUID, li->SeriesUID.GetCharData());
if (c != 0 || seriesUID == 0)
{
// Use UID to identify series, but use series number to sort.
int c2 = li->SeriesNumber - seriesNumber;
c = (c2 == 0 ? c : c2);
}
}
}
if (c == 0 && seriesUID != 0)
{
std::vector<FileInfo>::iterator pos =
li->Files.insert(
std::upper_bound(li->Files.begin(), li->Files.end(), fileInfo,
CompareInstance), fileInfo);
this->FillImageRecord(&pos->ImageRecord, meta);
li->QueryMatched |= queryMatched;
foundSeries = true;
break;
}
else if (c >= 0)
{
break;
}
}
if (!foundSeries)
{
li = sortedFiles.insert(li, SeriesInfo());
li->PatientName = patientNameValue;
li->PatientID = patientIDValue;
li->StudyDate = studyDateValue;
li->StudyUID = studyUIDValue;
li->SeriesUID = seriesUIDValue;
li->SeriesNumber = seriesNumber;
li->Files.push_back(fileInfo);
li->QueryMatched = queryMatched;
this->FillPatientRecord(&li->PatientRecord, meta);
this->FillStudyRecord(&li->StudyRecord, meta);
this->FillSeriesRecord(&li->SeriesRecord, meta);
this->FillImageRecord(&li->Files.back().ImageRecord, meta);
}
}
// Visit each series and call AddSeriesFileNames
int patientCount = this->GetNumberOfPatients();
int studyCount = this->GetNumberOfStudies();
vtkDICOMValue lastStudyUID;
vtkDICOMValue lastPatientID;
for (li = sortedFiles.begin(); li != sortedFiles.end(); ++li)
{
SeriesInfo &v = *li;
if (!v.QueryMatched) { continue; }
// Is this a new patient or a new study?
if (!lastPatientID.IsValid() || v.PatientID != lastPatientID)
{
lastPatientID = v.PatientID;
patientCount++;
lastStudyUID = v.StudyUID;
studyCount++;
}
else if (!lastStudyUID.IsValid() || v.StudyUID != lastStudyUID)
{
lastStudyUID = v.StudyUID;
studyCount++;
}
vtkSmartPointer<vtkStringArray> sa =
vtkSmartPointer<vtkStringArray>::New();
vtkIdType n = static_cast<vtkIdType>(v.Files.size());
sa->SetNumberOfValues(n);
std::vector<const vtkDICOMItem *> imageRecords(n);
for (vtkIdType i = 0; i < n; i++)
{
sa->SetValue(i, v.Files[i].FileName);
imageRecords[i] = &v.Files[i].ImageRecord;
}
this->AddSeriesFileNames(
patientCount-1, studyCount-1, sa,
v.PatientRecord, v.StudyRecord, v.SeriesRecord, &imageRecords[0]);
}
}
//----------------------------------------------------------------------------
namespace {
// Trivial structs needed by ProcessOsirixDatabase
struct StudyRow { vtkVariant col[12]; };
struct SeriesRow { vtkVariant col[8]; };
struct ImageRow { vtkVariant col[7]; };
// Decompress a SOPInstanceUID from an Osirix database
std::string DecompressUID(const std::string& s)
{
char uid[64];
size_t n = s.length();
size_t m = 0;
for (size_t i = 0; i < n && i < 32; i++)
{
unsigned char c = s[i];
c >>= 4;
if (c == 0) { break; }
c += ('0' - 1);
if (c > '9') { c = '.'; }
uid[m++] = c;
c = s[i];
c &= 0x0f;
if (c == 0) { break; }
c += ('0' - 1);
if (c > '9') { c = '.'; }
uid[m++] = c;
}
return std::string(uid, m);
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::ProcessOsirixDatabase(const char *fname)
{
// Open the database
vtkSmartPointer<vtkSQLiteDatabase> dbase =
vtkSmartPointer<vtkSQLiteDatabase>::New();
dbase->SetDatabaseFileName(fname);
if (!dbase->Open("", vtkSQLiteDatabase::USE_EXISTING))
{
vtkErrorMacro("Unable to open database file " << fname);
return;
}
// Make sure this is an OsiriX database file.
vtkStringArray *tables = dbase->GetTables();
int count = 0;
for (vtkIdType i = 0; i < tables->GetNumberOfValues(); i++)
{
std::string s = tables->GetValue(i);
count += (s == "ZSTUDY" || s == "ZSERIES" || s == "ZIMAGE");
}
if (count != 3)
{
return;
}
// Create the path to DATABASE.noindex, where .dcm files are stored
vtkDICOMFilePath path(fname);
path.PopBack();
path.PushBack("DATABASE.noindex");
vtkSQLQuery *q = dbase->GetQueryInstance();
// Indices to columns in the study table
enum {
ST_PK, ST_DATE, ST_DATEOFBIRTH, ST_MODALITY, ST_NAME,
ST_INSTITUTIONNAME, ST_STUDYNAME, ST_ID, ST_STUDYINSTANCEUID,
ST_ACCESSIONNUMBER, ST_PATIENTSEX, ST_PATIENTID, ST_NCOLS
};
// Indices to columns in the series table
enum {
SE_PK, SE_ID, SE_DATE, SE_SERIESSOPCLASSUID, SE_MODALITY,
SE_NAME, SE_SERIESDICOMUID, SE_SERIESDESCRIPTION, SE_NCOLS
};
// Indices to columns in the image table
enum {
IM_INSTANCENUMBER, IM_FRAMEID, IM_PATHNUMBER, IM_PATHSTRING,
IM_COMPRESSEDSOPINSTANCEUID, IM_STOREDHEIGHT, IM_STOREDWIDTH, IM_NCOLS
};
// These vectors will hold the tables
std::vector<StudyRow> studyTable;
std::vector<SeriesRow> seriesTable;
std::vector<ImageRow> imageTable;
// Acquire a shared lock while reading the three tables, to ensure that
// the three tables are consistent with each other.
q->BeginTransaction();
// Read the study table
if (!q->SetQuery("select Z_PK,ZDATE,ZDATEOFBIRTH,ZMODALITY,ZNAME,"
"ZINSTITUTIONNAME,ZSTUDYNAME,ZID,ZSTUDYINSTANCEUID,"
"ZACCESSIONNUMBER,ZPATIENTSEX,ZPATIENTID from ZSTUDY"
" order by ZDATE") ||
!q->Execute())
{
vtkErrorMacro("Badly structured ZSTUDY table: " << fname);
q->CommitTransaction();
q->Delete();
return;
}
while (q->NextRow())
{
studyTable.push_back(StudyRow());
StudyRow *row = &studyTable.back();
for (int k = 0; k < ST_NCOLS; k++)
{
row->col[k] = q->DataValue(k);
}
}
// Read the series table
if (!q->SetQuery("select Z_PK,ZID,ZDATE,ZSERIESSOPCLASSUID,"
"ZMODALITY,ZNAME,ZSERIESDICOMUID,ZSERIESDESCRIPTION,"
"ZSTUDY from ZSERIES order by ZSTUDY,ZID") ||
!q->Execute())
{
vtkErrorMacro("Badly structured ZSERIES table: " << fname);
q->CommitTransaction();
q->Delete();
return;
}
std::vector<vtkTypeInt64> zseriesVec;
while (q->NextRow())
{
seriesTable.push_back(SeriesRow());
SeriesRow *row = &seriesTable.back();
for (int k = 0; k < SE_NCOLS; k++)
{
row->col[k] = q->DataValue(k);
}
zseriesVec.push_back(q->DataValue(SE_NCOLS).ToTypeInt64());
}
// Read the image table
if (!q->SetQuery("select ZINSTANCENUMBER,ZFRAMEID,ZPATHNUMBER,"
"ZPATHSTRING,ZCOMPRESSEDSOPINSTANCEUID,"
"ZSTOREDHEIGHT,ZSTOREDWIDTH,ZSERIES"
" from ZIMAGE order by"
" ZSERIES,ZINSTANCENUMBER") ||
!q->Execute())
{
vtkErrorMacro("Badly structured IMAGE table: " << fname);
q->CommitTransaction();
q->Delete();
return;
}
std::vector<vtkTypeInt64> zimageVec;
while (q->NextRow())
{
imageTable.push_back(ImageRow());
ImageRow *row = &imageTable.back();
for (int k = 0; k < IM_NCOLS; k++)
{
row->col[k] = q->DataValue(k);
}
zimageVec.push_back(q->DataValue(IM_NCOLS).ToTypeInt64());
}
// Close the database and delete it by setting the smart pointer to NULL.
// Calling CommitTransaction doesn't write anything, because only SELECT
// has been used. Instead, it just releases the shared lock.
q->CommitTransaction();
q->Delete();
dbase = NULL;
// To track progress, count number of images processed.
size_t imageCounter = 0;
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
// Go through all of the studies
for (std::vector<StudyRow>::iterator st = studyTable.begin();
st != studyTable.end(); ++st)
{
vtkDICOMItem patientItem;
vtkDICOMItem studyItem;
vtkTypeInt64 zstudy = st->col[ST_PK].ToTypeInt64();
std::string name = st->col[ST_NAME].ToString();
std::string patientID = st->col[ST_PATIENTID].ToString();
// Seconds between our time base and database time base
const double timediff = 978307200.0;
double studySeconds = st->col[ST_DATE].ToDouble();
double birthSeconds = st->col[ST_DATEOFBIRTH].ToDouble();
std::string studyDT = vtkDICOMUtilities::GenerateDateTime(
static_cast<long long>((studySeconds + timediff)*1e6), NULL);
std::string birthDT = vtkDICOMUtilities::GenerateDateTime(
static_cast<long long>((birthSeconds + timediff)*1e6), NULL);
patientItem.SetAttributeValue(
DC::SpecificCharacterSet, vtkDICOMCharacterSet::ISO_IR_192);
patientItem.SetAttributeValue(DC::PatientName, name);
patientItem.SetAttributeValue(DC::PatientID, patientID);
patientItem.SetAttributeValue(DC::PatientBirthDate, birthDT.substr(0, 8));
patientItem.SetAttributeValue(
DC::PatientSex, st->col[ST_PATIENTSEX].ToString());
studyItem.SetAttributeValue(
DC::SpecificCharacterSet, vtkDICOMCharacterSet::ISO_IR_192);
studyItem.SetAttributeValue(
DC::StudyDescription, st->col[ST_STUDYNAME].ToString());
studyItem.SetAttributeValue(
DC::StudyID, st->col[ST_ID].ToString());
studyItem.SetAttributeValue(
DC::StudyInstanceUID, st->col[ST_STUDYINSTANCEUID].ToString());
studyItem.SetAttributeValue(
DC::InstitutionName, st->col[ST_INSTITUTIONNAME].ToString());
studyItem.SetAttributeValue(
DC::AccessionNumber, st->col[ST_ACCESSIONNUMBER].ToString());
studyItem.SetAttributeValue(DC::StudyDate, studyDT.substr(0,8));
studyItem.SetAttributeValue(DC::StudyTime, studyDT.substr(8,13));
int studyIdx = this->GetNumberOfStudies();
int patientIdx;
int firstUnusedPatientIdx = this->GetNumberOfPatients();
// Loop until corrent patientIdx is found
for (patientIdx = 0; patientIdx < firstUnusedPatientIdx; patientIdx++)
{
const vtkDICOMItem& pitem = this->GetPatientRecord(patientIdx);
const vtkDICOMValue& vid = pitem.GetAttributeValue(DC::PatientID);
if (vid.IsValid() && vid.GetVL() > 0)
{
if (patientID.length() > 0 && vid.Matches(patientID.c_str()))
{
break;
}
}
else // Use PatientName if PatientID is empty
{
const vtkDICOMValue& vna = pitem.GetAttributeValue(DC::PatientName);
if (vna.IsValid() && vna.GetVL() > 0)
{
if (name.length() > 0 && vna.Matches(name.c_str()))
{
break;
}
}
}
}
// Search for the first series in the study
std::vector<vtkTypeInt64>::iterator zseriesVecIter =
std::lower_bound(zseriesVec.begin(), zseriesVec.end(), zstudy);
size_t seIdx = std::distance(zseriesVec.begin(), zseriesVecIter);
// Go through all of the series in the study
for (std::vector<SeriesRow>::iterator se = seriesTable.begin() + seIdx;
se != seriesTable.end(); ++se)
{
// Break when we find a series that isn't part of the study
if (*zseriesVecIter > zstudy)
{
break;
}
++zseriesVecIter;
vtkDICOMItem seriesItem;
vtkTypeInt64 zseries = se->col[SE_PK].ToTypeInt64();
double seriesSeconds = se->col[SE_DATE].ToDouble();
std::string seriesDT = vtkDICOMUtilities::GenerateDateTime(
static_cast<long long>((seriesSeconds + timediff)*1e6), NULL);
vtkDICOMValue sopClassUID(
vtkDICOMVR::UI, se->col[SE_SERIESSOPCLASSUID].ToString());
std::string seriesUID = se->col[SE_SERIESDICOMUID].ToString();
// Remove any text before the UID
size_t k = 0;
while (k < seriesUID.length() &&
(seriesUID[k] <= '0' || seriesUID[k] >= '9'))
{
k++;
}
if (k > 0)
{
seriesUID = seriesUID.substr(k, seriesUID.length()-k);
}
seriesItem.SetAttributeValue(
DC::SpecificCharacterSet, vtkDICOMCharacterSet::ISO_IR_192);
seriesItem.SetAttributeValue(
DC::SeriesDescription, se->col[SE_NAME].ToString());
seriesItem.SetAttributeValue(
DC::ProtocolName, se->col[SE_SERIESDESCRIPTION].ToString());
seriesItem.SetAttributeValue(
DC::SeriesNumber, se->col[SE_ID].ToString());
seriesItem.SetAttributeValue(DC::SeriesInstanceUID, seriesUID);
seriesItem.SetAttributeValue(DC::SeriesDate, seriesDT.substr(0,8));
seriesItem.SetAttributeValue(DC::SeriesTime, seriesDT.substr(8,13));
seriesItem.SetAttributeValue(
DC::Modality, se->col[SE_MODALITY].ToString());
vtkSmartPointer<vtkStringArray> fileNames =
vtkSmartPointer<vtkStringArray>::New();
vtkDICOMSequence imageRecordSequence;
std::string lastpath;
// Search for the first image in the series
std::vector<vtkTypeInt64>::iterator zimageVecIter =
std::lower_bound(zimageVec.begin(), zimageVec.end(), zseries);
size_t imIdx = std::distance(zimageVec.begin(), zimageVecIter);
// Go through all of the images in the series
for (std::vector<ImageRow>::iterator im = imageTable.begin() + imIdx;
im != imageTable.end(); ++im)
{
// Break when we find a series that isn't part of the study
if (*zimageVecIter > zseries)
{
break;
}
++zimageVecIter;
std::string fpath = im->col[IM_PATHSTRING].ToString();
if (fpath.length() == 0)
{
// no PATHSTRING, so use PATHNUMBER instead
vtkTypeInt64 fnum = im->col[IM_PATHNUMBER].ToTypeInt64();
vtkTypeInt64 dnum = (fnum/10000 + 1)*10000;
vtkVariant fv(fnum);
vtkVariant dv(dnum);
path.PushBack(dv.ToString());
path.PushBack(fv.ToString() + ".dcm");
fpath = path.AsString();
path.PopBack();
path.PopBack();
}
else if (fpath[0] != '/')
{
// PATHSTRING is a local path, not an absolute path
vtkTypeInt64 fnum = atol(fpath.c_str());
vtkTypeInt64 dnum = (fnum/10000 + 1)*10000;
vtkVariant dv(dnum);
path.PushBack(dv.ToString());
path.PushBack(fpath);
fpath = path.AsString();
path.PopBack();
path.PopBack();
}
if (fpath != lastpath)
{
// Add the path to the list of filenames
vtkDICOMItem imageRecord;
imageRecord.SetAttributeValue(DC::SOPClassUID, sopClassUID);
imageRecord.SetAttributeValue(
DC::SOPInstanceUID,
DecompressUID(im->col[IM_COMPRESSEDSOPINSTANCEUID].ToString()));
imageRecord.SetAttributeValue(
DC::InstanceNumber, im->col[IM_INSTANCENUMBER].ToString());
imageRecord.SetAttributeValue(
DC::Rows, im->col[IM_STOREDHEIGHT].ToInt());
imageRecord.SetAttributeValue(
DC::Columns, im->col[IM_STOREDWIDTH].ToInt());
imageRecordSequence.AddItem(imageRecord);
fileNames->InsertNextValue(fpath);
lastpath = fpath;
}
// Increment the progress counter.
imageCounter++;
}
// Add the series if it passes the query
size_t n = imageRecordSequence.GetNumberOfItems();
if (n > 0)
{
const vtkDICOMItem *data = imageRecordSequence.GetSequenceData();
std::vector<const vtkDICOMItem *> imageRecords(n);
for (size_t i = 0; i < n; i++)
{
imageRecords[i] = &data[i];
}
// Set a flag to indicate that loose matching is needed, because
// the Osirix database "cleans" certain attribute value strings
this->UsingOsirixDatabase = true;
this->AddSeriesWithQuery(
patientIdx, studyIdx, fileNames,
patientItem, studyItem, seriesItem, &imageRecords[0]);
this->UsingOsirixDatabase = false;
}
// Check for abort and update progress at 1% intervals
if (!this->AbortExecute)
{
double progress = (imageCounter + 1.0)/imageTable.size();
if (progress == 1.0 || progress > this->GetProgress() + 0.01)
{
progress = static_cast<int>(progress*100.0)/100.0;
this->UpdateProgress(progress);
}
}
if (this->AbortExecute)
{
return;
}
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::ProcessDirectoryFile(
const char *dirname, vtkDICOMMetaData *meta)
{
// Get the ID of this file set (informative only).
if (meta->HasAttribute(DC::FileSetID))
{
std::string fileSetID = meta->GetAttributeValue(DC::FileSetID).AsString();
this->FileSetID = new char[fileSetID.length() + 1];
strcpy(this->FileSetID, fileSetID.c_str());
}
// Get the directory as a sequence.
const vtkDICOMValue& seq =
meta->GetAttributeValue(DC::DirectoryRecordSequence);
unsigned int n = seq.GetNumberOfValues();
const vtkDICOMItem *items = seq.GetSequenceData();
// The DICOMDIR uses byte offsets to identify items in the sequence.
std::map<unsigned int, unsigned int> offsetToIndexMap;
for (unsigned int i = 0; i < n; i++)
{
offsetToIndexMap[items[i].GetByteOffset()] = i;
}
// Get the first entry.
unsigned int offset =
meta->GetAttributeValue(
DC::OffsetOfTheFirstDirectoryRecordOfTheRootDirectoryEntity)
.AsUnsignedInt();
// This check is just for insurance.
if (offset == 0 && n > 0)
{
offset = items[0].GetByteOffset();
}
// To track progress, count number of items processed.
unsigned int itemCounter = 0;
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
// A stack to track the directory level.
std::vector<std::pair<unsigned int, std::string> > offsetStack;
int patientIdx = this->GetNumberOfPatients();
int studyIdx = this->GetNumberOfStudies();
unsigned int patientItem = 0;
unsigned int studyItem = 0;
unsigned int seriesItem = 0;
// List of filenames for the current series.
vtkSmartPointer<vtkStringArray> fileNames =
vtkSmartPointer<vtkStringArray>::New();
std::vector<const vtkDICOMItem *> imageRecords;
// The entry type that is currently being processed.
std::string entryType;
// Go through the directory, using the "next" and "child" pointers.
while (offset != 0)
{
unsigned int offsetOfChild = 0;
std::map<unsigned int, unsigned int>::iterator iter =
offsetToIndexMap.find(offset);
offset = 0;
if (iter != offsetToIndexMap.end() && iter->second != 0xffffffffu)
{
// Get the item index, mark the item as used.
unsigned int j = iter->second;
iter->second = 0xffffffffu;
offset = items[j].GetAttributeValue(
DC::OffsetOfTheNextDirectoryRecord).AsUnsignedInt();
offsetOfChild = items[j].GetAttributeValue(
DC::OffsetOfReferencedLowerLevelDirectoryEntity).AsUnsignedInt();
entryType = items[j].GetAttributeValue(
DC::DirectoryRecordType).AsString();
if (entryType == "PATIENT")
{
patientItem = j;
}
else if (entryType == "STUDY")
{
studyItem = j;
}
else if (entryType == "SERIES")
{
seriesItem = j;
}
else if (entryType == "IMAGE" || !this->RequirePixelData)
{
const vtkDICOMValue& fileID =
items[j].GetAttributeValue(DC::ReferencedFileID);
if (fileID.IsValid())
{
unsigned int m = fileID.GetNumberOfValues();
if (m > 0)
{
vtkDICOMFilePath path(dirname);
for (unsigned int k = 0; k < m; k++)
{
path.PushBack(fileID.GetString(k));
}
vtkIdType ki = fileNames->InsertNextValue(path.AsString());
imageRecords.push_back(&items[j]);
// sort the files by instance number, they will almost always
// already be in order so we use a simple algorithm
int inst = items[j].GetAttributeValue(DC::InstanceNumber).AsInt();
while (ki > 0)
{
const vtkDICOMItem *prev = imageRecords[--ki];
int inst2 = prev->GetAttributeValue(DC::InstanceNumber).AsInt();
if (inst < inst2)
{
std::string s = fileNames->GetValue(ki + 1);
fileNames->SetValue(ki + 1, fileNames->GetValue(ki));
fileNames->SetValue(ki, s);
std::swap(imageRecords[ki], imageRecords[ki + 1]);
}
else
{
// sorting is finished!
break;
}
}
}
}
}
}
if (offsetOfChild != 0)
{
// Go up one directory level.
offsetStack.push_back(std::make_pair(offset, entryType));
offset = offsetOfChild;
}
else
{
// Pop the stack until the next offset is not zero.
while (offset == 0 && offsetStack.size() > 0)
{
// Go down one directory level.
offset = offsetStack.back().first;
entryType = offsetStack.back().second;
offsetStack.pop_back();
if (entryType == "PATIENT")
{
// Get current max patient index plus one
patientIdx = this->GetNumberOfPatients();
}
else if (entryType == "STUDY")
{
// Get current max study index plus one
studyIdx = this->GetNumberOfStudies();
}
else if (entryType == "SERIES")
{
if (!imageRecords.empty())
{
// Add the series if it passes the query
this->AddSeriesWithQuery(
patientIdx, studyIdx, fileNames,
items[patientItem], items[studyItem], items[seriesItem],
&imageRecords[0]);
fileNames = vtkSmartPointer<vtkStringArray>::New();
imageRecords.clear();
}
}
}
}
// Check for abort and update progress at 1% intervals
if (!this->AbortExecute)
{
double progress = (itemCounter + 1.0)/n;
if (progress == 1.0 || progress > this->GetProgress() + 0.01)
{
progress = static_cast<int>(progress*100.0)/100.0;
this->UpdateProgress(progress);
}
}
if (this->AbortExecute)
{
return;
}
++itemCounter;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::ProcessDirectory(
const char *dirname, int depth, vtkStringArray *files)
{
// Check if the directory has been visited yet. This avoids infinite
// recursion when following circular links.
std::string realname = vtkDICOMFilePath(dirname).GetRealPath();
std::vector<std::string>::iterator viter =
std::lower_bound(this->Visited->begin(), this->Visited->end(), realname);
if (viter == this->Visited->end() || *viter != realname)
{
// Add this directory to the "visited" list.
this->Visited->insert(viter, realname);
}
else
{
// This directory has already been visited.
return;
}
// Find the path to the directory.
vtkDICOMFilePath path(dirname);
if (depth == this->ScanDepth)
{
// Build the path to the DICOMDIR file.
path.PushBack("DICOMDIR");
std::string dicomdir = path.AsString();
path.PopBack();
// Check to see if the DICOMDIR file exists.
if (vtkDICOMFile::Access(dicomdir.c_str(), vtkDICOMFile::In) == 0)
{
vtkSmartPointer<vtkDICOMMetaData> meta =
vtkSmartPointer<vtkDICOMMetaData>::New();
vtkDICOMParser *parser = vtkDICOMParser::New();
parser->AddObserver(
vtkCommand::ErrorEvent, this, &vtkDICOMDirectory::RelayError);
parser->SetMetaData(meta);
this->SetInternalFileName(dicomdir.c_str());
parser->SetFileName(dicomdir.c_str());
parser->Update();
unsigned long errorCode = parser->GetErrorCode();
parser->Delete();
if (errorCode && depth == 0)
{
// Only fail if depth is zero. Otherwise, we can ignore the
// DICOMDIR and look for the DICOM files directly.
this->ErrorCode = errorCode;
return;
}
else if (errorCode == 0)
{
// Process the DICOMDIR file.
this->ProcessDirectoryFile(dirname, meta);
return;
}
}
}
// If depth is zero, recursion is complete.
if (depth <= 0)
{
return;
}
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
vtkDICOMFileDirectory d(dirname);
if (d.GetError() != 0)
{
// Only fail at the initial depth.
if (depth == this->ScanDepth)
{
vtkErrorMacro(<< "Could not read directory " << dirname);
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
return;
}
}
int n = d.GetNumberOfFiles();
for (int i = 0; i < n; i++)
{
const char *fname = d.GetFile(i);
if ((fname[0] != '.' || (fname[1] != '\0' &&
(fname[1] != '.' || fname[2] != '\0'))) &&
strcmp(fname, "DICOMDIR") != 0)
{
path.PushBack(fname);
std::string fileString = path.AsString();
path.PopBack();
if (!this->FollowSymlinks && d.IsSymlink(i))
{
// Do nothing unless FollowSymlinks is On
}
#ifdef _WIN32
else if (!this->ShowHidden && d.IsHidden(i))
#else
else if (!this->ShowHidden && (d.IsHidden(i) || fname[0] == '.'))
#endif
{
// Do nothing for hidden files unless ShowHidden is On
// (on Linux and OS X, consider "." files to be hidden)
}
else if (d.IsDirectory(i))
{
if (depth > 1)
{
this->ProcessDirectory(fileString.c_str(), depth-1, files);
}
}
else if (this->FilePattern == 0 || this->FilePattern[0] == '\0' ||
vtkDICOMUtilities::PatternMatches(
this->FilePattern, fileString.c_str()))
{
files->InsertNextValue(fileString);
}
}
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::Execute()
{
// Clear the output
this->Series->clear();
this->Studies->clear();
this->Patients->clear();
this->Visited->clear();
delete [] this->FileSetID;
this->FileSetID = 0;
this->ErrorCode = 0;
this->InvokeEvent(vtkCommand::StartEvent);
vtkSmartPointer<vtkStringArray> files =
vtkSmartPointer<vtkStringArray>::New();
if (this->InputFileNames)
{
for (vtkIdType i = 0; i < this->InputFileNames->GetNumberOfValues(); i++)
{
const std::string& fname = this->InputFileNames->GetValue(i);
int code = vtkDICOMFile::Access(fname.c_str(), vtkDICOMFile::In);
if (code == vtkDICOMFile::FileIsDirectory)
{
this->ProcessDirectory(fname.c_str(), this->ScanDepth, files);
}
else if (code == vtkDICOMFile::FileNotFound)
{
this->ErrorCode = vtkErrorCode::FileNotFoundError;
vtkErrorMacro("File or directory not found: " << fname.c_str());
return;
}
else if (code == vtkDICOMFile::AccessDenied)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Permission denied: " << fname.c_str());
return;
}
else if (code == vtkDICOMFile::ImpossiblePath)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Bad file path: " << fname.c_str());
return;
}
else if (code != 0)
{
this->ErrorCode = vtkErrorCode::UnknownError;
vtkErrorMacro("Unknown file error: " << fname.c_str());
return;
}
else if (vtkDICOMUtilities::PatternMatches("*.sql", fname.c_str()))
{
this->ProcessOsirixDatabase(fname.c_str());
}
else if (this->FilePattern == 0 || this->FilePattern[0] == '\0' ||
vtkDICOMUtilities::PatternMatches(
this->FilePattern, fname.c_str()))
{
files->InsertNextValue(fname);
}
}
}
else
{
if (this->DirectoryName == 0)
{
// No directory is a valid input. Return an empty output.
return;
}
int code = vtkDICOMFile::Access(this->DirectoryName, vtkDICOMFile::In);
if (code == vtkDICOMFile::FileIsDirectory)
{
this->ProcessDirectory(this->DirectoryName, this->ScanDepth, files);
}
else if (code == vtkDICOMFile::FileNotFound)
{
this->ErrorCode = vtkErrorCode::FileNotFoundError;
vtkErrorMacro("Directory not found: " << this->DirectoryName);
return;
}
else if (code == vtkDICOMFile::AccessDenied)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Permission denied: " << this->DirectoryName);
return;
}
else if (code == vtkDICOMFile::ImpossiblePath)
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Bad file path: " << this->DirectoryName);
return;
}
else if (code != 0)
{
this->ErrorCode = vtkErrorCode::UnknownError;
vtkErrorMacro("Unknown error: " << this->DirectoryName);
return;
}
else
{
this->ErrorCode = vtkErrorCode::CannotOpenFileError;
vtkErrorMacro("Found a file, not a directory: " << this->DirectoryName);
return;
}
}
// Check for abort.
if (!this->AbortExecute)
{
this->UpdateProgress(0.0);
}
if (this->AbortExecute)
{
return;
}
if (files->GetNumberOfValues() > 0)
{
this->SortFiles(files);
}
this->InvokeEvent(vtkCommand::EndEvent);
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::Update(int)
{
this->AbortExecute = 0;
if (this->GetMTime() > this->UpdateTime.GetMTime())
{
this->Execute();
this->UpdateTime.Modified();
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::SetInternalFileName(const char *name)
{
if (this->InternalFileName == NULL && name == NULL)
{
return;
}
if (this->InternalFileName != 0 && name != 0 &&
strcmp(this->InternalFileName, name) == 0)
{
return;
}
if (this->InternalFileName)
{
delete [] this->InternalFileName;
}
if (name)
{
size_t n = strlen(name) + 1;
char *cp1 = new char[n];
const char *cp2 = (name);
this->InternalFileName = cp1;
do { *cp1++ = *cp2++; } while (--n);
}
else
{
this->InternalFileName = 0;
}
}
//----------------------------------------------------------------------------
void vtkDICOMDirectory::RelayError(vtkObject *o, unsigned long e, void *data)
{
if (e == vtkCommand::ErrorEvent)
{
vtkDICOMParser *parser = vtkDICOMParser::SafeDownCast(o);
if (parser)
{
this->SetErrorCode(parser->GetErrorCode());
this->SetInternalFileName(parser->GetFileName());
}
vtkErrorMacro(<< static_cast<char *>(data));
}
else
{
this->InvokeEvent(e, data);
}
}
|
/*
* Copyright 2014-2022 Real Logic Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <chrono>
#include <thread>
#include <iostream>
#include <iosfwd>
#include <vector>
#include <cstring>
#include <gtest/gtest.h>
#include "client/AeronArchive.h"
#include "client/RecordingPos.h"
#include "client/ReplayMerge.h"
#include "ChannelUriStringBuilder.h"
#include "CncFileReader.h"
#if defined(__linux__) || defined(Darwin)
#include <unistd.h>
#include <ftw.h>
#include <cstdio>
#include <spawn.h>
#include <pthread.h>
#elif defined(_WIN32)
#include <windows.h>
typedef intptr_t pid_t;
#else
#error "must spawn Java archive per test"
#endif
using namespace aeron;
using namespace aeron::util;
using namespace aeron::archive::client;
#ifdef _WIN32
static bool aeron_file_exists(const char *path)
{
DWORD dwAttrib = GetFileAttributes(path);
return dwAttrib != INVALID_FILE_ATTRIBUTES;
}
static int aeron_delete_directory(const char *dir)
{
char dir_buffer[1024] = { 0 };
size_t dir_length = strlen(dir);
if (dir_length > (1024 - 2))
{
return -1;
}
memcpy(dir_buffer, dir, dir_length);
dir_buffer[dir_length] = '\0';
dir_buffer[dir_length + 1] = '\0';
SHFILEOPSTRUCT file_op =
{
nullptr,
FO_DELETE,
dir_buffer,
nullptr,
FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT,
false,
nullptr,
nullptr
};
return SHFileOperation(&file_op);
}
#else
static bool aeron_file_exists(const char *path)
{
struct stat stat_info = {};
return stat(path, &stat_info) == 0;
}
static int aeron_unlink_func(const char *path, const struct stat *sb, int type_flag, struct FTW *ftw)
{
if (remove(path) != 0)
{
perror("remove");
}
return 0;
}
static int aeron_delete_directory(const char *dirname)
{
return nftw(dirname, aeron_unlink_func, 64, FTW_DEPTH | FTW_PHYS);
}
#endif
class AeronArchiveTest : public testing::Test
{
public:
~AeronArchiveTest() override
{
if (m_debug)
{
std::cout << m_stream.str();
}
}
void SetUp() final
{
m_stream << currentTimeMillis() << " [SetUp] Starting ArchivingMediaDriver..." << std::endl;
std::string aeronDirArg = "-Daeron.dir=" + m_context.aeronDirectoryName();
std::string archiveDirArg = "-Daeron.archive.dir=" + m_archiveDir;
const char * const argv[] =
{
"java",
#if JAVA_MAJOR_VERSION >= 9
"--add-opens",
"java.base/java.lang.reflect=ALL-UNNAMED",
"--add-opens",
"java.base/java.net=ALL-UNNAMED",
"--add-opens",
"java.base/sun.nio.ch=ALL-UNNAMED",
#endif
"-Daeron.dir.delete.on.start=true",
"-Daeron.dir.delete.on.shutdown=true",
"-Daeron.archive.dir.delete.on.start=true",
"-Daeron.archive.max.catalog.entries=128",
"-Daeron.term.buffer.sparse.file=true",
"-Daeron.perform.storage.checks=false",
"-Daeron.term.buffer.length=64k",
"-Daeron.ipc.term.buffer.length=64k",
"-Daeron.threading.mode=SHARED",
"-Daeron.shared.idle.strategy=backoff",
"-Daeron.archive.threading.mode=SHARED",
"-Daeron.archive.idle.strategy=backoff",
"-Daeron.archive.recording.events.enabled=false",
"-Daeron.driver.termination.validator=io.aeron.driver.DefaultAllowTerminationValidator",
"-Daeron.archive.authenticator.supplier=io.aeron.samples.archive.SampleAuthenticatorSupplier",
archiveDirArg.c_str(),
aeronDirArg.c_str(),
"-cp",
m_aeronAllJar.c_str(),
"io.aeron.archive.ArchivingMediaDriver",
nullptr
};
#if defined(_WIN32)
m_pid = _spawnv(P_NOWAIT, m_java.c_str(), &argv[0]);
#else
m_pid = -1;
if (0 != posix_spawn(&m_pid, m_java.c_str(), nullptr, nullptr, (char * const *)&argv[0], nullptr))
{
perror("spawn");
::exit(EXIT_FAILURE);
}
#endif
if (m_pid < 0)
{
perror("spawn");
::exit(EXIT_FAILURE);
}
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:admin");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials));
m_context.messageTimeoutNs(m_context.messageTimeoutNs());
m_stream << currentTimeMillis() << " [SetUp] ArchivingMediaDriver PID " << m_pid << std::endl;
const std::chrono::duration<long, std::milli> IDLE_SLEEP_MS_1(1);
std::this_thread::sleep_for(IDLE_SLEEP_MS_1);
}
void TearDown() final
{
if (0 != m_pid)
{
m_stream << currentTimeMillis() << " [TearDown] Shutting down PID " << m_pid << std::endl;
const std::string cncFilename = m_context.aeron()->context().cncFileName();
const std::string aeronPath = aeron::Context::defaultAeronPath();
m_context.aeron(nullptr);
printErrors(aeronPath);
if (aeron::Context::requestDriverTermination(aeronPath, nullptr, 0))
{
m_stream << currentTimeMillis() << " [TearDown] Waiting for driver termination" << std::endl;
const std::chrono::duration<long, std::milli> IDLE_SLEEP_MS_1(1);
while (aeron_file_exists(cncFilename.c_str()))
{
std::this_thread::sleep_for(IDLE_SLEEP_MS_1);
}
m_stream << currentTimeMillis() << " [TearDown] CnC file no longer exists" << std::endl;
#if defined(_WIN32)
WaitForSingleObject(reinterpret_cast<HANDLE>(m_pid), INFINITE);
#else
int process_status = -1;
do
{
waitpid(m_pid, &process_status, WUNTRACED);
}
while (0 >= WIFEXITED(process_status));
#endif
m_stream << currentTimeMillis() << " [TearDown] Driver terminated" << std::endl;
}
else
{
const auto now_ms = currentTimeMillis();
m_stream << now_ms << " [TearDown] Failed to send driver terminate command" << std::endl;
m_stream << now_ms << " [TearDown] Deleting " << m_archiveDir << std::endl;
if (aeron_delete_directory(m_archiveDir.c_str()) != 0)
{
m_stream << currentTimeMillis() << " [TearDown] Failed to delete " << m_archiveDir << std::endl;
}
}
}
}
void printErrors(const std::string &aeronPath)
{
const CncFileReader reader = aeron::CncFileReader::mapExisting(aeronPath.c_str());
int count = reader.readErrorLog(
[&](
std::int32_t observationCount,
std::int64_t firstObservationTimestamp,
std::int64_t lastObservationTimestamp,
const std::string &encodedException)
{
m_stream << "***\n" << observationCount
<< " observations for:\n " << encodedException.c_str() << std::endl;
},
0);
m_stream << std::endl << count << " distinct errors observed." << std::endl;
}
static std::shared_ptr<Publication> addPublication(Aeron &aeron, const std::string &channel, std::int32_t streamId)
{
std::int64_t publicationId = aeron.addPublication(channel, streamId);
std::shared_ptr<Publication> publication = aeron.findPublication(publicationId);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (!publication)
{
idleStrategy.idle();
publication = aeron.findPublication(publicationId);
}
return publication;
}
static std::shared_ptr<Subscription> addSubscription(
Aeron &aeron, const std::string &channel, std::int32_t streamId)
{
std::int64_t subscriptionId = aeron.addSubscription(channel, streamId);
std::shared_ptr<Subscription> subscription = aeron.findSubscription(subscriptionId);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (!subscription)
{
idleStrategy.idle();
subscription = aeron.findSubscription(subscriptionId);
}
return subscription;
}
static std::int32_t getRecordingCounterId(std::int32_t sessionId, CountersReader &countersReader)
{
std::int32_t counterId;
while (CountersReader::NULL_COUNTER_ID ==
(counterId = RecordingPos::findCounterIdBySessionId(countersReader, sessionId)))
{
std::this_thread::yield();
}
return counterId;
}
static void offerMessages(Publication &publication, std::size_t messageCount, const std::string &messagePrefix)
{
BufferClaim bufferClaim;
aeron::concurrent::YieldingIdleStrategy idleStrategy;
for (std::size_t i = 0; i < messageCount; i++)
{
const std::string message = messagePrefix + std::to_string(i);
while (publication.tryClaim(static_cast<util::index_t>(message.length()), bufferClaim) < 0)
{
idleStrategy.idle();
}
bufferClaim.buffer().putStringWithoutLength(bufferClaim.offset(), message);
bufferClaim.commit();
}
}
void consumeMessages(Subscription &subscription, std::size_t messageCount, const std::string &messagePrefix) const
{
std::size_t received = 0;
aeron::concurrent::YieldingIdleStrategy idleStrategy;
fragment_handler_t handler =
[&](AtomicBuffer &buffer, util::index_t offset, util::index_t length, Header &header)
{
const std::string expected = messagePrefix + std::to_string(received);
const std::string actual = buffer.getStringWithoutLength(offset, static_cast<std::size_t>(length));
EXPECT_EQ(expected, actual);
received++;
};
while (received < messageCount)
{
if (0 == subscription.poll(handler, m_fragmentLimit))
{
idleStrategy.idle();
}
}
ASSERT_EQ(received, messageCount);
}
bool attemptReplayMerge(
ReplayMerge &replayMerge,
Publication &publication,
fragment_handler_t &handler,
const std::string &messagePrefix,
std::size_t totalMessageCount,
std::size_t &messagesPublished,
std::size_t &receivedMessageCount) const
{
aeron::concurrent::YieldingIdleStrategy idleStrategy;
for (std::size_t i = messagesPublished; i < totalMessageCount; i++)
{
BufferClaim bufferClaim;
const std::string message = messagePrefix + std::to_string(i);
idleStrategy.reset();
while (publication.tryClaim(static_cast<util::index_t>(message.length()), bufferClaim) < 0)
{
idleStrategy.idle();
int fragments = replayMerge.poll(handler, m_fragmentLimit);
if (0 == fragments && replayMerge.hasFailed())
{
return false;
}
}
bufferClaim.buffer().putStringWithoutLength(bufferClaim.offset(), message);
bufferClaim.commit();
++messagesPublished;
int fragments = replayMerge.poll(handler, m_fragmentLimit);
if (0 == fragments && replayMerge.hasFailed())
{
return false;
}
}
while (!replayMerge.isMerged())
{
int fragments = replayMerge.poll(handler, m_fragmentLimit);
if (0 == fragments && replayMerge.hasFailed())
{
return false;
}
idleStrategy.idle(fragments);
}
Image &image = *replayMerge.image();
while (receivedMessageCount < totalMessageCount)
{
int fragments = image.poll(handler, m_fragmentLimit);
if (0 == fragments && image.isClosed())
{
return false;
}
idleStrategy.idle(fragments);
}
return true;
}
protected:
const std::string m_java = JAVA_EXECUTABLE;
const std::string m_aeronAllJar = AERON_ALL_JAR;
const std::string m_archiveDir = ARCHIVE_DIR;
const std::string m_recordingChannel = "aeron:udp?endpoint=localhost:3333";
const std::int32_t m_recordingStreamId = 33;
const std::string m_replayChannel = "aeron:udp?endpoint=localhost:6666";
const std::int32_t m_replayStreamId = 66;
const int m_fragmentLimit = 10;
AeronArchive::Context_t m_context;
pid_t m_pid = -1;
std::ostringstream m_stream;
bool m_debug = true;
};
TEST_F(AeronArchiveTest, shouldAsyncConnectToArchive)
{
std::shared_ptr<AeronArchive::AsyncConnect> asyncConnect = AeronArchive::asyncConnect(m_context);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
std::uint8_t previousStep = asyncConnect->step();
std::shared_ptr<AeronArchive> aeronArchive = asyncConnect->poll();
while (!aeronArchive)
{
if (asyncConnect->step() == previousStep)
{
idleStrategy.idle();
}
else
{
idleStrategy.reset();
previousStep = asyncConnect->step();
}
aeronArchive = asyncConnect->poll();
}
EXPECT_TRUE(aeronArchive->controlResponsePoller().subscription()->isConnected());
}
TEST_F(AeronArchiveTest, shouldConnectToArchive)
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
EXPECT_TRUE(aeronArchive->controlResponsePoller().subscription()->isConnected());
}
TEST_F(AeronArchiveTest, shouldRecordPublicationAndFindRecording)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingIdFromCounter), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
const std::int64_t recordingId = aeronArchive->findLastMatchingRecording(
0, "endpoint=localhost:3333", m_recordingStreamId, sessionId);
EXPECT_EQ(recordingIdFromCounter, recordingId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), stopPosition);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[&](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
EXPECT_EQ(recordingId, recordingId1);
EXPECT_EQ(streamId, m_recordingStreamId);
});
EXPECT_EQ(count, 1);
}
TEST_F(AeronArchiveTest, shouldRecordThenReplay)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
}
aeronArchive->stopRecording(subscriptionId);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (aeronArchive->getStopPosition(recordingIdFromCounter) != stopPosition)
{
idleStrategy.idle();
}
{
const std::int64_t position = 0L;
const std::int64_t length = stopPosition - position;
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_replayChannel, m_replayStreamId);
aeronArchive->startReplay(recordingIdFromCounter, position, length, m_replayChannel, m_replayStreamId);
consumeMessages(*subscription, messageCount, messagePrefix);
EXPECT_EQ(stopPosition, subscription->imageByIndex(0)->position());
}
}
TEST_F(AeronArchiveTest, shouldRecordThenReplayThenTruncate)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingIdFromCounter), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
const std::int64_t recordingId = aeronArchive->findLastMatchingRecording(
0, "endpoint=localhost:3333", m_recordingStreamId, sessionId);
EXPECT_EQ(recordingIdFromCounter, recordingId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), stopPosition);
const std::int64_t position = 0L;
{
const std::int64_t length = stopPosition - position;
std::shared_ptr<Subscription> subscription = aeronArchive->replay(
recordingId, position, length, m_replayChannel, m_replayStreamId);
consumeMessages(*subscription, messageCount, messagePrefix);
EXPECT_EQ(stopPosition, subscription->imageByIndex(0)->position());
}
aeronArchive->truncateRecording(recordingId, position);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
EXPECT_EQ(startPosition, newStopPosition);
});
EXPECT_EQ(count, 1);
}
TEST_F(AeronArchiveTest, shouldRecordAndCancelReplayEarly)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int64_t recordingId;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = aeronArchive->addRecordedPublication(
m_recordingChannel, m_recordingStreamId);
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(publication->sessionId(), countersReader);
recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingId), stopPosition);
aeronArchive->stopRecording(publication);
idleStrategy.reset();
while (NULL_POSITION != aeronArchive->getRecordingPosition(recordingId))
{
idleStrategy.idle();
}
}
const std::int64_t position = 0L;
const std::int64_t length = stopPosition - position;
const std::int64_t replaySessionId = aeronArchive->startReplay(
recordingId, position, length, m_replayChannel, m_replayStreamId);
aeronArchive->stopReplay(replaySessionId);
}
TEST_F(AeronArchiveTest, shouldReplayRecordingFromLateJoinPosition)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL, true);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(publication->sessionId(), countersReader);
const std::int64_t recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
const std::int64_t currentPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < currentPosition)
{
idleStrategy.idle();
}
{
std::shared_ptr<Subscription> replaySubscription = aeronArchive->replay(
recordingId, currentPosition, NULL_LENGTH, m_replayChannel, m_replayStreamId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
consumeMessages(*replaySubscription, messageCount, messagePrefix);
const std::int64_t endPosition = publication->position();
EXPECT_EQ(endPosition, replaySubscription->imageByIndex(0)->position());
}
}
}
struct SubscriptionDescriptor
{
const std::int64_t m_controlSessionId;
const std::int64_t m_correlationId;
const std::int64_t m_subscriptionId;
const std::int32_t m_streamId;
SubscriptionDescriptor(
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t subscriptionId,
std::int32_t streamId) :
m_controlSessionId(controlSessionId),
m_correlationId(correlationId),
m_subscriptionId(subscriptionId),
m_streamId(streamId)
{
}
};
TEST_F(AeronArchiveTest, shouldListRegisteredRecordingSubscriptions)
{
std::vector<SubscriptionDescriptor> descriptors;
recording_subscription_descriptor_consumer_t consumer =
[&descriptors](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t subscriptionId,
std::int32_t streamId,
const std::string &strippedChannel)
{
descriptors.emplace_back(controlSessionId, correlationId, subscriptionId, streamId);
};
const std::int32_t expectedStreamId = 7;
const std::string channelOne = "aeron:ipc";
const std::string channelTwo = "aeron:udp?endpoint=localhost:5678";
const std::string channelThree = "aeron:udp?endpoint=localhost:4321";
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subIdOne = aeronArchive->startRecording(
channelOne, expectedStreamId, AeronArchive::SourceLocation::LOCAL);
const std::int64_t subIdTwo = aeronArchive->startRecording(
channelTwo, expectedStreamId + 1, AeronArchive::SourceLocation::LOCAL);
const std::int64_t subIdThree = aeronArchive->startRecording(
channelThree, expectedStreamId + 2, AeronArchive::SourceLocation::LOCAL);
const std::int32_t countOne = aeronArchive->listRecordingSubscriptions(
0, 5, "ipc", expectedStreamId, true, consumer);
EXPECT_EQ(1uL, descriptors.size());
EXPECT_EQ(1L, countOne);
descriptors.clear();
const std::int32_t countTwo = aeronArchive->listRecordingSubscriptions(
0, 5, "", expectedStreamId, false, consumer);
EXPECT_EQ(3uL, descriptors.size());
EXPECT_EQ(3L, countTwo);
aeronArchive->stopRecording(subIdTwo);
descriptors.clear();
const std::int32_t countThree = aeronArchive->listRecordingSubscriptions(
0, 5, "", expectedStreamId, false, consumer);
EXPECT_EQ(2uL, descriptors.size());
EXPECT_EQ(2L, countThree);
EXPECT_EQ(1L, std::count_if(
descriptors.begin(),
descriptors.end(),
[=](const SubscriptionDescriptor &descriptor){ return descriptor.m_subscriptionId == subIdOne;}));
EXPECT_EQ(1L, std::count_if(
descriptors.begin(),
descriptors.end(),
[=](const SubscriptionDescriptor &descriptor){ return descriptor.m_subscriptionId == subIdThree;}));
}
TEST_F(AeronArchiveTest, shouldMergeFromReplayToLive)
{
const std::size_t termLength = 64 * 1024;
const std::string messagePrefix = "Message ";
const std::size_t minMessagesPerTerm = termLength / (messagePrefix.length() + DataFrameHeader::LENGTH);
const std::string controlEndpoint = "localhost:23265";
const std::string recordingEndpoint = "localhost:23266";
const std::string liveEndpoint = "localhost:23267";
const std::string replayEndpoint = "localhost:0";
const std::string publicationChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.tags("1,2")
.controlEndpoint(controlEndpoint)
.controlMode(MDC_CONTROL_MODE_DYNAMIC)
.flowControl("tagged,g:99901/1,t:5s")
.termLength(termLength)
.build();
const std::string liveDestination = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.endpoint(liveEndpoint)
.controlEndpoint(controlEndpoint)
.build();
const std::string replayDestination = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.endpoint(replayEndpoint)
.build();
const std::string replayChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.isSessionIdTagged(true)
.sessionId(2)
.build();
const std::size_t initialMessageCount = minMessagesPerTerm * 3;
const std::size_t subsequentMessageCount = minMessagesPerTerm * 3;
const std::size_t totalMessageCount = initialMessageCount + subsequentMessageCount;
aeron::concurrent::YieldingIdleStrategy idleStrategy;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), publicationChannel, m_recordingStreamId);
const std::int32_t sessionId = publication->sessionId();
const std::string recordingChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.groupTag(99901)
.sessionId(sessionId)
.endpoint(recordingEndpoint)
.controlEndpoint(controlEndpoint)
.build();
const std::string subscriptionChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.controlMode(MDC_CONTROL_MODE_MANUAL)
.sessionId(sessionId)
.build();
aeronArchive->startRecording(
recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::REMOTE, true);
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
const std::int64_t recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, initialMessageCount, messagePrefix);
while (countersReader.getCounterValue(counterId) < publication->position())
{
idleStrategy.idle();
}
std::size_t messagesPublished = initialMessageCount;
std::size_t receivedMessageCount = 0;
std::int64_t receivedPosition = 0;
fragment_handler_t fragment_handler =
[&](AtomicBuffer &buffer, util::index_t offset, util::index_t length, Header &header)
{
const std::string expected = messagePrefix + std::to_string(receivedMessageCount);
const std::string actual = buffer.getStringWithoutLength(offset, static_cast<std::size_t>(length));
EXPECT_EQ(expected, actual);
receivedMessageCount++;
receivedPosition = header.position();
};
while (true)
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), subscriptionChannel, m_recordingStreamId);
ReplayMerge replayMerge(
subscription,
aeronArchive,
replayChannel,
replayDestination,
liveDestination,
recordingId,
receivedPosition);
if (attemptReplayMerge(
replayMerge,
*publication,
fragment_handler,
messagePrefix,
totalMessageCount,
messagesPublished,
receivedMessageCount))
{
break;
}
idleStrategy.reset();
idleStrategy.idle();
}
EXPECT_EQ(receivedMessageCount, totalMessageCount);
EXPECT_EQ(receivedPosition, publication->position());
}
TEST_F(AeronArchiveTest, shouldExceptionForIncorrectInitialCredentials)
{
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:NotAdmin");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials));
ASSERT_THROW(
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
},
ArchiveException);
}
TEST_F(AeronArchiveTest, shouldBeAbleToHandleBeingChallenged)
{
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:adminC");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
auto onChallenge =
[](std::pair<const char *, std::uint32_t> encodedChallenge) -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:CSadmin");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials, onChallenge));
ASSERT_NO_THROW(
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
});
}
TEST_F(AeronArchiveTest, shouldExceptionForIncorrectChallengeCredentials)
{
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:adminC");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
auto onChallenge =
[](std::pair<const char *, std::uint32_t> encodedChallenge) -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:adminNoCS");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials, onChallenge));
ASSERT_THROW(
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
},
ArchiveException);
}
TEST_F(AeronArchiveTest, shouldPurgeStoppedRecording)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingIdFromCounter), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
const std::int64_t recordingId = aeronArchive->findLastMatchingRecording(
0, "endpoint=localhost:3333", m_recordingStreamId, sessionId);
EXPECT_EQ(recordingIdFromCounter, recordingId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), stopPosition);
aeronArchive->purgeRecording(recordingId);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
FAIL();
});
EXPECT_EQ(count, 0);
}
TEST_F(AeronArchiveTest, shouldReadJumboRecordingDescriptor)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingId;
std::int64_t stopPosition;
std::string recordingChannel = "aeron:udp?endpoint=localhost:3333|term-length=64k|alias=";
recordingChannel.append(2000, 'X');
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingId), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingId), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingId), stopPosition);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[&](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
EXPECT_EQ(recordingId, recordingId1);
EXPECT_EQ(streamId, m_recordingStreamId);
});
EXPECT_EQ(count, 1);
}
[C++] Test different idle strategy in archive test.
/*
* Copyright 2014-2022 Real Logic Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <chrono>
#include <thread>
#include <iostream>
#include <iosfwd>
#include <vector>
#include <cstring>
#include <gtest/gtest.h>
#include "client/AeronArchive.h"
#include "client/RecordingPos.h"
#include "client/ReplayMerge.h"
#include "ChannelUriStringBuilder.h"
#include "CncFileReader.h"
#if defined(__linux__) || defined(Darwin)
#include <unistd.h>
#include <ftw.h>
#include <cstdio>
#include <spawn.h>
#include <pthread.h>
#elif defined(_WIN32)
#include <windows.h>
typedef intptr_t pid_t;
#else
#error "must spawn Java archive per test"
#endif
using namespace aeron;
using namespace aeron::util;
using namespace aeron::archive::client;
#ifdef _WIN32
static bool aeron_file_exists(const char *path)
{
DWORD dwAttrib = GetFileAttributes(path);
return dwAttrib != INVALID_FILE_ATTRIBUTES;
}
static int aeron_delete_directory(const char *dir)
{
char dir_buffer[1024] = { 0 };
size_t dir_length = strlen(dir);
if (dir_length > (1024 - 2))
{
return -1;
}
memcpy(dir_buffer, dir, dir_length);
dir_buffer[dir_length] = '\0';
dir_buffer[dir_length + 1] = '\0';
SHFILEOPSTRUCT file_op =
{
nullptr,
FO_DELETE,
dir_buffer,
nullptr,
FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT,
false,
nullptr,
nullptr
};
return SHFileOperation(&file_op);
}
#else
static bool aeron_file_exists(const char *path)
{
struct stat stat_info = {};
return stat(path, &stat_info) == 0;
}
static int aeron_unlink_func(const char *path, const struct stat *sb, int type_flag, struct FTW *ftw)
{
if (remove(path) != 0)
{
perror("remove");
}
return 0;
}
static int aeron_delete_directory(const char *dirname)
{
return nftw(dirname, aeron_unlink_func, 64, FTW_DEPTH | FTW_PHYS);
}
#endif
class AeronArchiveTest : public testing::Test
{
public:
~AeronArchiveTest() override
{
if (m_debug)
{
std::cout << m_stream.str();
}
}
void SetUp() final
{
m_stream << currentTimeMillis() << " [SetUp] Starting ArchivingMediaDriver..." << std::endl;
std::string aeronDirArg = "-Daeron.dir=" + m_context.aeronDirectoryName();
std::string archiveDirArg = "-Daeron.archive.dir=" + m_archiveDir;
const char * const argv[] =
{
"java",
#if JAVA_MAJOR_VERSION >= 9
"--add-opens",
"java.base/java.lang.reflect=ALL-UNNAMED",
"--add-opens",
"java.base/java.net=ALL-UNNAMED",
"--add-opens",
"java.base/sun.nio.ch=ALL-UNNAMED",
#endif
"-Daeron.dir.delete.on.start=true",
"-Daeron.dir.delete.on.shutdown=true",
"-Daeron.archive.dir.delete.on.start=true",
"-Daeron.archive.max.catalog.entries=128",
"-Daeron.term.buffer.sparse.file=true",
"-Daeron.perform.storage.checks=false",
"-Daeron.term.buffer.length=64k",
"-Daeron.ipc.term.buffer.length=64k",
"-Daeron.threading.mode=SHARED",
"-Daeron.shared.idle.strategy=yield",
"-Daeron.archive.threading.mode=SHARED",
"-Daeron.archive.idle.strategy=yield",
"-Daeron.archive.recording.events.enabled=false",
"-Daeron.driver.termination.validator=io.aeron.driver.DefaultAllowTerminationValidator",
"-Daeron.archive.authenticator.supplier=io.aeron.samples.archive.SampleAuthenticatorSupplier",
archiveDirArg.c_str(),
aeronDirArg.c_str(),
"-cp",
m_aeronAllJar.c_str(),
"io.aeron.archive.ArchivingMediaDriver",
nullptr
};
#if defined(_WIN32)
m_pid = _spawnv(P_NOWAIT, m_java.c_str(), &argv[0]);
#else
m_pid = -1;
if (0 != posix_spawn(&m_pid, m_java.c_str(), nullptr, nullptr, (char * const *)&argv[0], nullptr))
{
perror("spawn");
::exit(EXIT_FAILURE);
}
#endif
if (m_pid < 0)
{
perror("spawn");
::exit(EXIT_FAILURE);
}
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:admin");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials));
m_context.messageTimeoutNs(m_context.messageTimeoutNs());
m_stream << currentTimeMillis() << " [SetUp] ArchivingMediaDriver PID " << m_pid << std::endl;
const std::chrono::duration<long, std::milli> IDLE_SLEEP_MS_1(1);
std::this_thread::sleep_for(IDLE_SLEEP_MS_1);
}
void TearDown() final
{
if (0 != m_pid)
{
m_stream << currentTimeMillis() << " [TearDown] Shutting down PID " << m_pid << std::endl;
const std::string cncFilename = m_context.aeron()->context().cncFileName();
const std::string aeronPath = aeron::Context::defaultAeronPath();
m_context.aeron(nullptr);
printErrors(aeronPath);
if (aeron::Context::requestDriverTermination(aeronPath, nullptr, 0))
{
m_stream << currentTimeMillis() << " [TearDown] Waiting for driver termination" << std::endl;
const std::chrono::duration<long, std::milli> IDLE_SLEEP_MS_1(1);
while (aeron_file_exists(cncFilename.c_str()))
{
std::this_thread::sleep_for(IDLE_SLEEP_MS_1);
}
m_stream << currentTimeMillis() << " [TearDown] CnC file no longer exists" << std::endl;
#if defined(_WIN32)
WaitForSingleObject(reinterpret_cast<HANDLE>(m_pid), INFINITE);
#else
int process_status = -1;
do
{
waitpid(m_pid, &process_status, WUNTRACED);
}
while (0 >= WIFEXITED(process_status));
#endif
m_stream << currentTimeMillis() << " [TearDown] Driver terminated" << std::endl;
}
else
{
const auto now_ms = currentTimeMillis();
m_stream << now_ms << " [TearDown] Failed to send driver terminate command" << std::endl;
m_stream << now_ms << " [TearDown] Deleting " << m_archiveDir << std::endl;
if (aeron_delete_directory(m_archiveDir.c_str()) != 0)
{
m_stream << currentTimeMillis() << " [TearDown] Failed to delete " << m_archiveDir << std::endl;
}
}
}
}
void printErrors(const std::string &aeronPath)
{
const CncFileReader reader = aeron::CncFileReader::mapExisting(aeronPath.c_str());
int count = reader.readErrorLog(
[&](
std::int32_t observationCount,
std::int64_t firstObservationTimestamp,
std::int64_t lastObservationTimestamp,
const std::string &encodedException)
{
m_stream << "***\n" << observationCount
<< " observations for:\n " << encodedException.c_str() << std::endl;
},
0);
m_stream << std::endl << count << " distinct errors observed." << std::endl;
}
static std::shared_ptr<Publication> addPublication(Aeron &aeron, const std::string &channel, std::int32_t streamId)
{
std::int64_t publicationId = aeron.addPublication(channel, streamId);
std::shared_ptr<Publication> publication = aeron.findPublication(publicationId);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (!publication)
{
idleStrategy.idle();
publication = aeron.findPublication(publicationId);
}
return publication;
}
static std::shared_ptr<Subscription> addSubscription(
Aeron &aeron, const std::string &channel, std::int32_t streamId)
{
std::int64_t subscriptionId = aeron.addSubscription(channel, streamId);
std::shared_ptr<Subscription> subscription = aeron.findSubscription(subscriptionId);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (!subscription)
{
idleStrategy.idle();
subscription = aeron.findSubscription(subscriptionId);
}
return subscription;
}
static std::int32_t getRecordingCounterId(std::int32_t sessionId, CountersReader &countersReader)
{
std::int32_t counterId;
while (CountersReader::NULL_COUNTER_ID ==
(counterId = RecordingPos::findCounterIdBySessionId(countersReader, sessionId)))
{
std::this_thread::yield();
}
return counterId;
}
static void offerMessages(Publication &publication, std::size_t messageCount, const std::string &messagePrefix)
{
BufferClaim bufferClaim;
aeron::concurrent::YieldingIdleStrategy idleStrategy;
for (std::size_t i = 0; i < messageCount; i++)
{
const std::string message = messagePrefix + std::to_string(i);
while (publication.tryClaim(static_cast<util::index_t>(message.length()), bufferClaim) < 0)
{
idleStrategy.idle();
}
bufferClaim.buffer().putStringWithoutLength(bufferClaim.offset(), message);
bufferClaim.commit();
}
}
void consumeMessages(Subscription &subscription, std::size_t messageCount, const std::string &messagePrefix) const
{
std::size_t received = 0;
aeron::concurrent::YieldingIdleStrategy idleStrategy;
fragment_handler_t handler =
[&](AtomicBuffer &buffer, util::index_t offset, util::index_t length, Header &header)
{
const std::string expected = messagePrefix + std::to_string(received);
const std::string actual = buffer.getStringWithoutLength(offset, static_cast<std::size_t>(length));
EXPECT_EQ(expected, actual);
received++;
};
while (received < messageCount)
{
if (0 == subscription.poll(handler, m_fragmentLimit))
{
idleStrategy.idle();
}
}
ASSERT_EQ(received, messageCount);
}
bool attemptReplayMerge(
ReplayMerge &replayMerge,
Publication &publication,
fragment_handler_t &handler,
const std::string &messagePrefix,
std::size_t totalMessageCount,
std::size_t &messagesPublished,
std::size_t &receivedMessageCount) const
{
aeron::concurrent::YieldingIdleStrategy idleStrategy;
for (std::size_t i = messagesPublished; i < totalMessageCount; i++)
{
BufferClaim bufferClaim;
const std::string message = messagePrefix + std::to_string(i);
idleStrategy.reset();
while (publication.tryClaim(static_cast<util::index_t>(message.length()), bufferClaim) < 0)
{
idleStrategy.idle();
int fragments = replayMerge.poll(handler, m_fragmentLimit);
if (0 == fragments && replayMerge.hasFailed())
{
return false;
}
}
bufferClaim.buffer().putStringWithoutLength(bufferClaim.offset(), message);
bufferClaim.commit();
++messagesPublished;
int fragments = replayMerge.poll(handler, m_fragmentLimit);
if (0 == fragments && replayMerge.hasFailed())
{
return false;
}
}
while (!replayMerge.isMerged())
{
int fragments = replayMerge.poll(handler, m_fragmentLimit);
if (0 == fragments && replayMerge.hasFailed())
{
return false;
}
idleStrategy.idle(fragments);
}
Image &image = *replayMerge.image();
while (receivedMessageCount < totalMessageCount)
{
int fragments = image.poll(handler, m_fragmentLimit);
if (0 == fragments && image.isClosed())
{
return false;
}
idleStrategy.idle(fragments);
}
return true;
}
protected:
const std::string m_java = JAVA_EXECUTABLE;
const std::string m_aeronAllJar = AERON_ALL_JAR;
const std::string m_archiveDir = ARCHIVE_DIR;
const std::string m_recordingChannel = "aeron:udp?endpoint=localhost:3333";
const std::int32_t m_recordingStreamId = 33;
const std::string m_replayChannel = "aeron:udp?endpoint=localhost:6666";
const std::int32_t m_replayStreamId = 66;
const int m_fragmentLimit = 10;
AeronArchive::Context_t m_context;
pid_t m_pid = -1;
std::ostringstream m_stream;
bool m_debug = true;
};
TEST_F(AeronArchiveTest, shouldAsyncConnectToArchive)
{
std::shared_ptr<AeronArchive::AsyncConnect> asyncConnect = AeronArchive::asyncConnect(m_context);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
std::uint8_t previousStep = asyncConnect->step();
std::shared_ptr<AeronArchive> aeronArchive = asyncConnect->poll();
while (!aeronArchive)
{
if (asyncConnect->step() == previousStep)
{
idleStrategy.idle();
}
else
{
idleStrategy.reset();
previousStep = asyncConnect->step();
}
aeronArchive = asyncConnect->poll();
}
EXPECT_TRUE(aeronArchive->controlResponsePoller().subscription()->isConnected());
}
TEST_F(AeronArchiveTest, shouldConnectToArchive)
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
EXPECT_TRUE(aeronArchive->controlResponsePoller().subscription()->isConnected());
}
TEST_F(AeronArchiveTest, shouldRecordPublicationAndFindRecording)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingIdFromCounter), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
const std::int64_t recordingId = aeronArchive->findLastMatchingRecording(
0, "endpoint=localhost:3333", m_recordingStreamId, sessionId);
EXPECT_EQ(recordingIdFromCounter, recordingId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), stopPosition);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[&](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
EXPECT_EQ(recordingId, recordingId1);
EXPECT_EQ(streamId, m_recordingStreamId);
});
EXPECT_EQ(count, 1);
}
TEST_F(AeronArchiveTest, shouldRecordThenReplay)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
}
aeronArchive->stopRecording(subscriptionId);
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (aeronArchive->getStopPosition(recordingIdFromCounter) != stopPosition)
{
idleStrategy.idle();
}
{
const std::int64_t position = 0L;
const std::int64_t length = stopPosition - position;
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_replayChannel, m_replayStreamId);
aeronArchive->startReplay(recordingIdFromCounter, position, length, m_replayChannel, m_replayStreamId);
consumeMessages(*subscription, messageCount, messagePrefix);
EXPECT_EQ(stopPosition, subscription->imageByIndex(0)->position());
}
}
TEST_F(AeronArchiveTest, shouldRecordThenReplayThenTruncate)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingIdFromCounter), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
const std::int64_t recordingId = aeronArchive->findLastMatchingRecording(
0, "endpoint=localhost:3333", m_recordingStreamId, sessionId);
EXPECT_EQ(recordingIdFromCounter, recordingId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), stopPosition);
const std::int64_t position = 0L;
{
const std::int64_t length = stopPosition - position;
std::shared_ptr<Subscription> subscription = aeronArchive->replay(
recordingId, position, length, m_replayChannel, m_replayStreamId);
consumeMessages(*subscription, messageCount, messagePrefix);
EXPECT_EQ(stopPosition, subscription->imageByIndex(0)->position());
}
aeronArchive->truncateRecording(recordingId, position);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
EXPECT_EQ(startPosition, newStopPosition);
});
EXPECT_EQ(count, 1);
}
TEST_F(AeronArchiveTest, shouldRecordAndCancelReplayEarly)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int64_t recordingId;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = aeronArchive->addRecordedPublication(
m_recordingChannel, m_recordingStreamId);
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(publication->sessionId(), countersReader);
recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingId), stopPosition);
aeronArchive->stopRecording(publication);
idleStrategy.reset();
while (NULL_POSITION != aeronArchive->getRecordingPosition(recordingId))
{
idleStrategy.idle();
}
}
const std::int64_t position = 0L;
const std::int64_t length = stopPosition - position;
const std::int64_t replaySessionId = aeronArchive->startReplay(
recordingId, position, length, m_replayChannel, m_replayStreamId);
aeronArchive->stopReplay(replaySessionId);
}
TEST_F(AeronArchiveTest, shouldReplayRecordingFromLateJoinPosition)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL, true);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(publication->sessionId(), countersReader);
const std::int64_t recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
const std::int64_t currentPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < currentPosition)
{
idleStrategy.idle();
}
{
std::shared_ptr<Subscription> replaySubscription = aeronArchive->replay(
recordingId, currentPosition, NULL_LENGTH, m_replayChannel, m_replayStreamId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
consumeMessages(*replaySubscription, messageCount, messagePrefix);
const std::int64_t endPosition = publication->position();
EXPECT_EQ(endPosition, replaySubscription->imageByIndex(0)->position());
}
}
}
struct SubscriptionDescriptor
{
const std::int64_t m_controlSessionId;
const std::int64_t m_correlationId;
const std::int64_t m_subscriptionId;
const std::int32_t m_streamId;
SubscriptionDescriptor(
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t subscriptionId,
std::int32_t streamId) :
m_controlSessionId(controlSessionId),
m_correlationId(correlationId),
m_subscriptionId(subscriptionId),
m_streamId(streamId)
{
}
};
TEST_F(AeronArchiveTest, shouldListRegisteredRecordingSubscriptions)
{
std::vector<SubscriptionDescriptor> descriptors;
recording_subscription_descriptor_consumer_t consumer =
[&descriptors](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t subscriptionId,
std::int32_t streamId,
const std::string &strippedChannel)
{
descriptors.emplace_back(controlSessionId, correlationId, subscriptionId, streamId);
};
const std::int32_t expectedStreamId = 7;
const std::string channelOne = "aeron:ipc";
const std::string channelTwo = "aeron:udp?endpoint=localhost:5678";
const std::string channelThree = "aeron:udp?endpoint=localhost:4321";
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subIdOne = aeronArchive->startRecording(
channelOne, expectedStreamId, AeronArchive::SourceLocation::LOCAL);
const std::int64_t subIdTwo = aeronArchive->startRecording(
channelTwo, expectedStreamId + 1, AeronArchive::SourceLocation::LOCAL);
const std::int64_t subIdThree = aeronArchive->startRecording(
channelThree, expectedStreamId + 2, AeronArchive::SourceLocation::LOCAL);
const std::int32_t countOne = aeronArchive->listRecordingSubscriptions(
0, 5, "ipc", expectedStreamId, true, consumer);
EXPECT_EQ(1uL, descriptors.size());
EXPECT_EQ(1L, countOne);
descriptors.clear();
const std::int32_t countTwo = aeronArchive->listRecordingSubscriptions(
0, 5, "", expectedStreamId, false, consumer);
EXPECT_EQ(3uL, descriptors.size());
EXPECT_EQ(3L, countTwo);
aeronArchive->stopRecording(subIdTwo);
descriptors.clear();
const std::int32_t countThree = aeronArchive->listRecordingSubscriptions(
0, 5, "", expectedStreamId, false, consumer);
EXPECT_EQ(2uL, descriptors.size());
EXPECT_EQ(2L, countThree);
EXPECT_EQ(1L, std::count_if(
descriptors.begin(),
descriptors.end(),
[=](const SubscriptionDescriptor &descriptor){ return descriptor.m_subscriptionId == subIdOne;}));
EXPECT_EQ(1L, std::count_if(
descriptors.begin(),
descriptors.end(),
[=](const SubscriptionDescriptor &descriptor){ return descriptor.m_subscriptionId == subIdThree;}));
}
TEST_F(AeronArchiveTest, shouldMergeFromReplayToLive)
{
const std::size_t termLength = 64 * 1024;
const std::string messagePrefix = "Message ";
const std::size_t minMessagesPerTerm = termLength / (messagePrefix.length() + DataFrameHeader::LENGTH);
const std::string controlEndpoint = "localhost:23265";
const std::string recordingEndpoint = "localhost:23266";
const std::string liveEndpoint = "localhost:23267";
const std::string replayEndpoint = "localhost:0";
const std::string publicationChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.tags("1,2")
.controlEndpoint(controlEndpoint)
.controlMode(MDC_CONTROL_MODE_DYNAMIC)
.flowControl("tagged,g:99901/1,t:5s")
.termLength(termLength)
.build();
const std::string liveDestination = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.endpoint(liveEndpoint)
.controlEndpoint(controlEndpoint)
.build();
const std::string replayDestination = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.endpoint(replayEndpoint)
.build();
const std::string replayChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.isSessionIdTagged(true)
.sessionId(2)
.build();
const std::size_t initialMessageCount = minMessagesPerTerm * 3;
const std::size_t subsequentMessageCount = minMessagesPerTerm * 3;
const std::size_t totalMessageCount = initialMessageCount + subsequentMessageCount;
aeron::concurrent::YieldingIdleStrategy idleStrategy;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), publicationChannel, m_recordingStreamId);
const std::int32_t sessionId = publication->sessionId();
const std::string recordingChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.groupTag(99901)
.sessionId(sessionId)
.endpoint(recordingEndpoint)
.controlEndpoint(controlEndpoint)
.build();
const std::string subscriptionChannel = ChannelUriStringBuilder()
.media(UDP_MEDIA)
.controlMode(MDC_CONTROL_MODE_MANUAL)
.sessionId(sessionId)
.build();
aeronArchive->startRecording(
recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::REMOTE, true);
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
const std::int64_t recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, initialMessageCount, messagePrefix);
while (countersReader.getCounterValue(counterId) < publication->position())
{
idleStrategy.idle();
}
std::size_t messagesPublished = initialMessageCount;
std::size_t receivedMessageCount = 0;
std::int64_t receivedPosition = 0;
fragment_handler_t fragment_handler =
[&](AtomicBuffer &buffer, util::index_t offset, util::index_t length, Header &header)
{
const std::string expected = messagePrefix + std::to_string(receivedMessageCount);
const std::string actual = buffer.getStringWithoutLength(offset, static_cast<std::size_t>(length));
EXPECT_EQ(expected, actual);
receivedMessageCount++;
receivedPosition = header.position();
};
while (true)
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), subscriptionChannel, m_recordingStreamId);
ReplayMerge replayMerge(
subscription,
aeronArchive,
replayChannel,
replayDestination,
liveDestination,
recordingId,
receivedPosition);
if (attemptReplayMerge(
replayMerge,
*publication,
fragment_handler,
messagePrefix,
totalMessageCount,
messagesPublished,
receivedMessageCount))
{
break;
}
idleStrategy.reset();
idleStrategy.idle();
}
EXPECT_EQ(receivedMessageCount, totalMessageCount);
EXPECT_EQ(receivedPosition, publication->position());
}
TEST_F(AeronArchiveTest, shouldExceptionForIncorrectInitialCredentials)
{
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:NotAdmin");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials));
ASSERT_THROW(
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
},
ArchiveException);
}
TEST_F(AeronArchiveTest, shouldBeAbleToHandleBeingChallenged)
{
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:adminC");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
auto onChallenge =
[](std::pair<const char *, std::uint32_t> encodedChallenge) -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:CSadmin");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials, onChallenge));
ASSERT_NO_THROW(
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
});
}
TEST_F(AeronArchiveTest, shouldExceptionForIncorrectChallengeCredentials)
{
auto onEncodedCredentials =
[]() -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:adminC");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
auto onChallenge =
[](std::pair<const char *, std::uint32_t> encodedChallenge) -> std::pair<const char *, std::uint32_t>
{
std::string credentials("admin:adminNoCS");
char *arr = new char[credentials.length() + 1];
std::memcpy(arr, credentials.data(), credentials.length());
arr[credentials.length()] = '\0';
return { arr, static_cast<std::uint32_t>(credentials.length()) };
};
m_context.credentialsSupplier(CredentialsSupplier(onEncodedCredentials, onChallenge));
ASSERT_THROW(
{
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
},
ArchiveException);
}
TEST_F(AeronArchiveTest, shouldPurgeStoppedRecording)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingIdFromCounter;
std::int64_t stopPosition;
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
m_recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), m_recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingIdFromCounter = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingIdFromCounter), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
const std::int64_t recordingId = aeronArchive->findLastMatchingRecording(
0, "endpoint=localhost:3333", m_recordingStreamId, sessionId);
EXPECT_EQ(recordingIdFromCounter, recordingId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingIdFromCounter), stopPosition);
aeronArchive->purgeRecording(recordingId);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
FAIL();
});
EXPECT_EQ(count, 0);
}
TEST_F(AeronArchiveTest, shouldReadJumboRecordingDescriptor)
{
const std::string messagePrefix = "Message ";
const std::size_t messageCount = 10;
std::int32_t sessionId;
std::int64_t recordingId;
std::int64_t stopPosition;
std::string recordingChannel = "aeron:udp?endpoint=localhost:3333|term-length=64k|alias=";
recordingChannel.append(2000, 'X');
std::shared_ptr<AeronArchive> aeronArchive = AeronArchive::connect(m_context);
const std::int64_t subscriptionId = aeronArchive->startRecording(
recordingChannel, m_recordingStreamId, AeronArchive::SourceLocation::LOCAL);
{
std::shared_ptr<Subscription> subscription = addSubscription(
*aeronArchive->context().aeron(), recordingChannel, m_recordingStreamId);
std::shared_ptr<Publication> publication = addPublication(
*aeronArchive->context().aeron(), recordingChannel, m_recordingStreamId);
sessionId = publication->sessionId();
CountersReader &countersReader = aeronArchive->context().aeron()->countersReader();
const std::int32_t counterId = getRecordingCounterId(sessionId, countersReader);
recordingId = RecordingPos::getRecordingId(countersReader, counterId);
offerMessages(*publication, messageCount, messagePrefix);
consumeMessages(*subscription, messageCount, messagePrefix);
stopPosition = publication->position();
aeron::concurrent::YieldingIdleStrategy idleStrategy;
while (countersReader.getCounterValue(counterId) < stopPosition)
{
idleStrategy.idle();
}
EXPECT_EQ(aeronArchive->getRecordingPosition(recordingId), stopPosition);
EXPECT_EQ(aeronArchive->getStopPosition(recordingId), aeron::NULL_VALUE);
}
aeronArchive->stopRecording(subscriptionId);
EXPECT_EQ(aeronArchive->getStopPosition(recordingId), stopPosition);
const std::int32_t count = aeronArchive->listRecording(
recordingId,
[&](
std::int64_t controlSessionId,
std::int64_t correlationId,
std::int64_t recordingId1,
std::int64_t startTimestamp,
std::int64_t stopTimestamp,
std::int64_t startPosition,
std::int64_t newStopPosition,
std::int32_t initialTermId,
std::int32_t segmentFileLength,
std::int32_t termBufferLength,
std::int32_t mtuLength,
std::int32_t sessionId1,
std::int32_t streamId,
const std::string &strippedChannel,
const std::string &originalChannel,
const std::string &sourceIdentity)
{
EXPECT_EQ(recordingId, recordingId1);
EXPECT_EQ(streamId, m_recordingStreamId);
});
EXPECT_EQ(count, 1);
}
|
/*------------------------------------------------------------------------
* (The MIT License)
*
* Copyright (c) 2008-2011 Rhomobile, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* http://rhomobile.com
*------------------------------------------------------------------------*/
#include "stdafx.h"
#include "NetRequestImpl.h"
#include "common/RhoFile.h"
#include "common/RhoFilePath.h"
#include "common/RhodesAppBase.h"
#include "common/StringConverter.h"
#include "net/URI.h"
#include "common/RhoConf.h"
#if defined(_WIN32_WCE)&& !defined( OS_PLATFORM_MOTCE )
#include <connmgr.h>
#endif
#ifdef OS_WINCE
extern "C" int strnicmp( const char *s1, const char *s2, size_t count );
#endif
namespace rho {
namespace net {
IMPLEMENT_LOGCLASS(CNetRequestImpl,"Net");
common::CMutex CNetRequestImpl::m_mxInternet;
HINTERNET CNetRequestImpl::m_hInternet;
HANDLE CNetRequestImpl::m_hWceConnMgrConnection;
CNetRequestImpl::CNetRequestImpl()
{
m_hConnection = 0;
m_hRequest = 0;
memset(&m_uri, 0, sizeof(m_uri) );
m_pHeaders = 0;
m_bCancel = false;
m_pSession = 0;
m_sslVerifyPeer = true;
}
void CNetRequestImpl::init(const char* method, const String& strUrl, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
{
m_pHeaders = pHeaders;
m_bCancel = false;
m_pSession = oSession;
m_strErrFunction = L"";
m_hConnection = NULL;
m_hRequest = NULL;
memset(&m_uri, 0, sizeof(m_uri) );
m_strUrl = strUrl;
CAtlStringW strUrlW(strUrl.c_str());
LOG(INFO) + "Method: " + method + ";Url: " + strUrl;
do
{
if ( !initConnection(RHODESAPPBASE().isBaseUrl(strUrl.c_str()), strUrlW) )
break;
DWORD dwUrlLength = 1024;
CAtlStringW strCanonicalUrlW;
if ( !InternetCanonicalizeUrl( strUrlW, strCanonicalUrlW.GetBuffer(dwUrlLength), &dwUrlLength, 0) )
{
m_strErrFunction = _T("InternetCanonicalizeUrl");
break;
}
strCanonicalUrlW.ReleaseBuffer();
alloc_url_components( &m_uri, strCanonicalUrlW );
if( !InternetCrackUrl( strCanonicalUrlW, strCanonicalUrlW.GetLength(), 0, &m_uri ) )
{
m_strErrFunction = L"InternetCrackUrl";
break;
}
m_hConnection = InternetConnect( m_hInternet, m_uri.lpszHostName, m_uri.nPort, _T("anonymous"),
NULL, INTERNET_SERVICE_HTTP, 0, 0 );
if ( !m_hConnection )
{
m_strErrFunction = L"InternetConnect";
break;
}
int timeout = rho_conf_getInt("net_timeout")*1000;
if (timeout == 0 )
timeout = 30000;
InternetSetOption( m_hInternet, INTERNET_OPTION_RECEIVE_TIMEOUT, &timeout, sizeof(timeout) );
m_strReqUrlW = m_uri.lpszUrlPath;
m_strReqUrlW += m_uri.lpszExtraInfo;
DWORD dwFlags = INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_NO_CACHE_WRITE|INTERNET_FLAG_NO_COOKIES|INTERNET_FLAG_NO_AUTO_REDIRECT;
if ( m_uri.lpszScheme && wcsicmp(m_uri.lpszScheme,L"https")==0)
dwFlags |= INTERNET_FLAG_SECURE;
if ( !m_sslVerifyPeer )
dwFlags |= INTERNET_FLAG_IGNORE_CERT_CN_INVALID|INTERNET_FLAG_IGNORE_CERT_DATE_INVALID;
m_hRequest = HttpOpenRequest( m_hConnection, CAtlStringW(method), m_strReqUrlW, NULL, NULL, NULL, dwFlags, NULL );
if ( !m_hRequest )
{
m_strErrFunction = L"HttpOpenRequest";
break;
}
if (oSession!=null)
{
String strSession = oSession->getSession();
LOG(INFO) + "Cookie : " + strSession;
if ( strSession.length() > 0 )
{
String strHeader = "Cookie: " + strSession + "\r\n";
if ( !HttpAddRequestHeaders( m_hRequest, common::convertToStringW(strHeader).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + common::convertToStringW(strHeader);
}
}
if (RHOCONF().isExist("http_proxy_host"))
{
rho::String strLogin, strPassword;
if (RHOCONF().isExist("http_proxy_login"))
strLogin = RHOCONF().getString ("http_proxy_login");
if (RHOCONF().isExist("http_proxy_password"))
strPassword = RHOCONF().getString("http_proxy_password");
if ( strPassword.length() > 0 && strLogin.length() > 0 )
{
String strAuth = strLogin+":"+strPassword;
int nLen = rho_base64_encode(strAuth.c_str(), -1, 0);
char* szBuf = new char[nLen+1];
rho_base64_encode(strAuth.c_str(), -1, szBuf );
String strHeader = "Proxy-Authorization: Basic ";
strHeader += szBuf;
strHeader += "\r\n";
delete szBuf;
if ( !HttpAddRequestHeaders( m_hRequest, common::convertToStringW(strHeader).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + common::convertToStringW(strHeader);
}
}
}while(0);
}
boolean CNetRequestImpl::checkSslCertError()
{
DWORD dwError = GetLastError ();
if (!m_sslVerifyPeer &&(
(dwError == ERROR_INTERNET_INVALID_CA) ||
(dwError == ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED) ||
(dwError == ERROR_INTERNET_SEC_CERT_DATE_INVALID) ||
(dwError == ERROR_INTERNET_SEC_CERT_CN_INVALID)))
{
DWORD dwFlag;
DWORD dwBuffLen = sizeof(dwFlag);
InternetQueryOption (m_hRequest, INTERNET_OPTION_SECURITY_FLAGS,(LPVOID)&dwFlag, &dwBuffLen);
dwFlag |= (SECURITY_FLAG_IGNORE_UNKNOWN_CA
| SECURITY_FLAG_IGNORE_CERT_CN_INVALID
| SECURITY_FLAG_IGNORE_CERT_DATE_INVALID );
InternetSetOption (m_hRequest, INTERNET_OPTION_SECURITY_FLAGS, &dwFlag, sizeof (dwFlag) );
/*
INTERNET_CERTIFICATE_INFO sInfo;
DWORD dwSize = sizeof(sInfo);
if(!InternetQueryOption(m_hSess,INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
&sInfo, &dwSize))
{
dwError = GetLastError();
}
*/
return true;
}
return false;
}
String CNetRequestImpl::getBodyContentType()
{
if ( m_pSession )
return m_pSession->getContentType();
else
return "application/x-www-form-urlencoded";
}
INetResponse* CNetRequestImpl::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
{
init( method, strUrl, oSession, pHeaders );
CNetResponseImpl* pNetResp = new CNetResponseImpl;
do
{
if ( isError() )
break;
if ( strBody.length() > 0 )
{
CAtlStringW strHeaders = L"Content-Type: ";
strHeaders += getBodyContentType().c_str();
strHeaders += L"\r\n";
if ( !HttpAddRequestHeaders( m_hRequest, strHeaders, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + strHeaders.GetString();
break;
}
}
writeHeaders(m_pHeaders);
if ( isError() )
break;
if ( !HttpSendRequest( m_hRequest, NULL, 0, const_cast<char*>(strBody.c_str()), strBody.length() ) )
{
if (!m_bCancel && checkSslCertError())
{
if ( !HttpSendRequest( m_hRequest, NULL, 0, const_cast<char*>(strBody.c_str()), strBody.length() ) )
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}else
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}
readResponse(pNetResp);
if ( isError() )
break;
readInetFile(m_hRequest,pNetResp);
}while(0);
return pNetResp;
}
void CNetRequestImpl::writeHeaders(Hashtable<String,String>* pHeaders)
{
if ( pHeaders && pHeaders->size() > 0 )
{
String strHeaders;
for ( Hashtable<String,String>::iterator it = pHeaders->begin(); it != pHeaders->end(); ++it )
{
if ( it->first.length() > 0 )
strHeaders += it->first + ":" + (it->second.length() ? it->second : "''") + "\r\n";
}
if ( !HttpAddRequestHeaders( m_hRequest, common::convertToStringW(strHeaders).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + common::convertToStringW(strHeaders);
return;
}
}
}
boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders)
{
oHeaders.clear();
CAtlStringW strHeaders;
DWORD dwLen = 0;
DWORD nIndex = 0;
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, null, &dwLen, &nIndex) )
{
DWORD dwErr = ::GetLastError();
if ( dwErr != ERROR_INSUFFICIENT_BUFFER )
{
m_strErrFunction = L"HttpQueryInfo";
return false;
}
}
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, strHeaders.GetBuffer(dwLen), &dwLen, &nIndex) )
{
m_strErrFunction = L"HttpQueryInfo";
return false;
}
strHeaders.ReleaseBuffer();
int nStart = 0;
for(int nEnd = strHeaders.Find(L"\r\n", nStart); nEnd > 0; nStart = nEnd+2, nEnd = strHeaders.Find(L"\r\n", nStart) )
{
CAtlStringW strHeader = strHeaders.Mid(nStart, nEnd-nStart);
int nSep = strHeader.Find(':');
if (nSep < 0 )
continue;
CAtlStringW strName = strHeader.Mid(0, nSep);
strName.Trim();
strName.MakeLower();
CAtlStringW strValue = strHeader.Mid(nSep+1);
strValue.Trim();
String strFieldName = common::convertToStringA(strName.GetString());
String strFieldValue = common::convertToStringA(strValue.GetString());
LOG(TRACE) + strFieldName + ":" + strFieldValue;
if ( oHeaders.containsKey(strFieldName) )
{
strFieldValue += ";" + oHeaders.get( strFieldName );
oHeaders.put( strFieldName, strFieldValue );
}
else
oHeaders.put( strFieldName, strFieldValue );
}
return true;
}
String CNetRequestImpl::makeClientCookie()
{
DWORD nIndex = 0;
String cookie;
while(true)
{
CAtlStringW strCookie;
DWORD dwLen = 0;
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_SET_COOKIE, null, &dwLen, &nIndex) )
{
DWORD dwErr = ::GetLastError();
if ( dwErr == ERROR_HTTP_HEADER_NOT_FOUND )
break;
if ( dwErr != ERROR_INSUFFICIENT_BUFFER )
{
m_strErrFunction = L"HttpQueryInfo";
break;
}
}
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_SET_COOKIE, strCookie.GetBuffer(dwLen), &dwLen, &nIndex) )
{
m_strErrFunction = L"HttpQueryInfo";
break;
}
strCookie.ReleaseBuffer();
URI::parseCookie(common::convertToStringA(strCookie.GetString()).c_str(), cookie);
}
if ( m_strErrFunction.length() > 0 )
return "";
// if ( cookie.strAuth.length() > 0 || cookie.strSession.length() >0 )
// return cookie.strAuth + ";" + cookie.strSession + ";";
return cookie;
}
void CNetRequestImpl::readResponse(CNetResponseImpl* pNetResp)
{
DWORD dwLen = 10;
wchar_t szHttpRes[10];
DWORD nIndex = 0;
if ( m_bCancel )
return;
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_STATUS_CODE, szHttpRes, &dwLen, &nIndex) )
{
m_strErrFunction = L"HttpQueryInfo";
return;
}
int nCode = _wtoi(szHttpRes);
pNetResp->setResponseCode(nCode);
if ( m_pHeaders )
{
if ( !readHeaders(*m_pHeaders) )
return;
}
//if ( nCode != 200 && nCode != 206 && nCode != 416 )
if ( nCode >= 400 && nCode != 416 )
{
LOG(ERROR) + "An error occured connecting to the server: " + szHttpRes + " returned.";
// If we're unauthorized, delete any cookies that might have been
// stored so we don't reuse them later
if ( nCode == 401 && m_pSession )
{
LOG(ERROR) + "Unauthorize error.Client will be logged out";
m_pSession->logout();
}
}
if (pNetResp->isSuccess())
pNetResp->setCookies(makeClientCookie());
}
INetResponse* CNetRequestImpl::pullFile(const String& strUrl, common::CRhoFile& oFile, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
{
init("GET", strUrl, oSession, pHeaders);
CNetResponseImpl* pNetResp = new CNetResponseImpl;
const int nDownloadBufferSize = 1024*100;
char* pDownloadBuffer = 0;
do
{
writeHeaders(m_pHeaders);
if ( isError() )
break;
if ( oFile.size() > 0 )
{
CAtlStringW strHeaders = L"Range: bytes=";
strHeaders += common::convertToStringW(oFile.size()).c_str();
strHeaders += L"-";
//strHeaders += common::convertToStringW(oFile.size()+30068032).c_str();
strHeaders += "\r\n";
if ( !HttpAddRequestHeaders( m_hRequest, strHeaders, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + strHeaders.GetString();
break;
}
}
if ( !HttpSendRequest( m_hRequest, NULL, 0, NULL, 0 ) )
{
if (!m_bCancel && checkSslCertError())
{
if ( !HttpSendRequest( m_hRequest, NULL, 0, NULL, 0 ) )
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}else
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}
readResponse(pNetResp);
if ( isError() )
break;
if ( pNetResp->getRespCode() == 200 )
oFile.movePosToStart();
if ( pNetResp->getRespCode() == 416 )
{
pNetResp->setResponseCode(206);
break;
}
if ( pNetResp->isOK() )
{
if (!pDownloadBuffer)
pDownloadBuffer = new char[nDownloadBufferSize];
readInetFile(m_hRequest,pNetResp, &oFile, pDownloadBuffer, nDownloadBufferSize);
}else
readInetFile(m_hRequest,pNetResp);
}while(0);
if (pDownloadBuffer)
delete pDownloadBuffer;
return pNetResp;
}
static const wchar_t* szMultipartContType =
L"Content-Type: multipart/form-data; boundary=----------A6174410D6AD474183FDE48F5662FCC5\r\n";
static const char* szMultipartPostfix =
"\r\n------------A6174410D6AD474183FDE48F5662FCC5--";
int CNetRequestImpl::processMultipartItems( VectorPtr<CMultipartItem*>& arItems )
{
int nSize = 0;
for( int i = 0; i < (int)arItems.size(); i++ )
{
CMultipartItem& oItem = *arItems.elementAt(i);
if ( oItem.m_strName.length() == 0 )
oItem.m_strName = "blob";
if ( oItem.m_strFileName.length() == 0 )
{
if ( oItem.m_strFilePath.length() > 0 )
{
common::CFilePath oPath(oItem.m_strFilePath);
oItem.m_strFileName = oPath.getBaseName();
}
//else
// oItem.m_strFileName = "doesnotmatter.txt";
}
oItem.m_strDataPrefix = i > 0 ? "\r\n" : "";
oItem.m_strDataPrefix +=
"------------A6174410D6AD474183FDE48F5662FCC5\r\n"
"Content-Disposition: form-data; name=\"";
oItem.m_strDataPrefix += oItem.m_strName + "\"";
if (oItem.m_strFileName.length()>0)
oItem.m_strDataPrefix += "; filename=\"" + oItem.m_strFileName + "\"";
oItem.m_strDataPrefix += "\r\n";
if ( oItem.m_strContentType.length() > 0 )
oItem.m_strDataPrefix += "Content-Type: " + oItem.m_strContentType + "\r\n";
int nContentSize = 0;
if ( oItem.m_strFilePath.length() > 0 )
{
common::CRhoFile oFile;
if ( oFile.open(oItem.m_strFilePath.c_str(),common::CRhoFile::OpenReadOnly) )
nContentSize = oFile.size();
}
else
nContentSize = oItem.m_strBody.length();
if ( oItem.m_strContentType.length() > 0 )
oItem.m_strDataPrefix += "Content-Length: " + common::convertToStringA(nContentSize) + "\r\n";
oItem.m_strDataPrefix += "\r\n";
nSize += oItem.m_strDataPrefix.length() + nContentSize;
}
nSize += strlen(szMultipartPostfix);
return nSize;
}
INetResponse* CNetRequestImpl::pushMultipartData(const String& strUrl, VectorPtr<CMultipartItem*>& arItems, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
{
init("POST", strUrl, oSession, pHeaders );
CNetResponseImpl* pNetResp = new CNetResponseImpl;
do
{
writeHeaders(m_pHeaders);
if ( isError() )
break;
if ( !HttpAddRequestHeaders( m_hRequest, szMultipartContType, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + szMultipartContType;
break;
}
INTERNET_BUFFERS BufferIn;
memset(&BufferIn, 0, sizeof(INTERNET_BUFFERS));
BufferIn.dwStructSize = sizeof( INTERNET_BUFFERS ); // Must be set or error will occur
BufferIn.dwBufferTotal = processMultipartItems( arItems );
if(!HttpSendRequestEx( m_hRequest, &BufferIn, NULL, 0, 0))
{
if (checkSslCertError())
{
if(!HttpSendRequestEx( m_hRequest, &BufferIn, NULL, 0, 0))
{
m_strErrFunction = L"HttpSendRequestEx";
break;
}
}else
{
m_strErrFunction = L"HttpSendRequestEx";
break;
}
}
//write all items
for( int i = 0; i < (int)arItems.size(); i++ )
{
CMultipartItem& oItem = *arItems.elementAt(i);
if ( oItem.m_strFilePath.length() > 0 )
{
common::CRhoFile oFile;
if ( !oFile.open(oItem.m_strFilePath.c_str(),common::CRhoFile::OpenReadOnly) )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
common::InputStream* bodyStream = oFile.getInputStream();
if ( !internetWriteHeader( oItem.m_strDataPrefix.c_str(), "", "") )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
DWORD dwBytesWritten = 0;
if ( bodyStream->available() > 0 )
{
DWORD dwBufSize = 4096;
char* pBuf = (char*)malloc(dwBufSize);
int nReaded = 0;
do
{
nReaded = bodyStream->read(pBuf,0,dwBufSize);
if ( nReaded > 0 )
{
if ( !InternetWriteFile( m_hRequest, pBuf, nReaded, &dwBytesWritten) )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
}
}while(nReaded > 0);
free(pBuf);
}
}else
{
if ( !internetWriteHeader( oItem.m_strDataPrefix.c_str(), oItem.m_strBody.c_str(), "") )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
}
}
if ( !internetWriteHeader( "", "", szMultipartPostfix) )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
if ( !HttpEndRequest(m_hRequest, NULL, 0, 0) )
{
m_strErrFunction = L"HttpEndRequest";
break;
}
if ( isError() )
break;
readResponse(pNetResp);
if ( isError() )
break;
readInetFile(m_hRequest,pNetResp);
}while(0);
return pNetResp;
}
bool CNetRequestImpl::internetWriteHeader( const char* szPrefix, const char* szBody, const char* szPrefixEnd)
{
DWORD dwBytesWritten = 0;
if ( szPrefix && *szPrefix && !InternetWriteFile( m_hRequest, szPrefix, strlen(szPrefix), &dwBytesWritten) )
return false;
if ( szBody && *szBody && !InternetWriteFile( m_hRequest, szBody, strlen(szBody), &dwBytesWritten) )
return false;
if ( szPrefixEnd && *szPrefixEnd && !InternetWriteFile( m_hRequest, szPrefixEnd, strlen(szPrefixEnd), &dwBytesWritten) )
return false;
return true;
}
void CNetRequestImpl::cancel()
{
m_bCancel = true;
if ( m_hRequest )
InternetCloseHandle(m_hRequest);
if ( m_hConnection )
InternetCloseHandle(m_hConnection);
/* if ( hInet )
InternetCloseHandle(hInet); */
/*
hRequest = 0;
hConnection = 0;
hInet = 0;*/
}
void CNetRequestImpl::close()
{
if (!m_bCancel && m_strErrFunction.length()>0)
ErrorMessage(m_strErrFunction.c_str());
free_url_components(&m_uri);
if ( m_hRequest )
InternetCloseHandle(m_hRequest);
if ( m_hConnection )
InternetCloseHandle(m_hConnection);
// if ( hInet )
// InternetCloseHandle(hInet);
memset(&m_uri, 0, sizeof(m_uri));
m_hRequest = 0;
m_hConnection = 0;
// hInet = 0;
}
CNetRequestImpl::~CNetRequestImpl()
{
close();
}
void CNetRequestImpl::readInetFile( HINTERNET hRequest, CNetResponseImpl* pNetResp, common::CRhoFile* pFile /*=NULL*/,
char* pBuf, DWORD dwBufSize )
{
if (m_bCancel)
return;
//if ( pNetResp->getRespCode() == 500 || pNetResp->getRespCode() == 422 )
// return;
char* pBufToFree = 0;
if (!pBuf)
{
if ( dwBufSize==0)
dwBufSize=1024*50;
pBuf = (char*)malloc(dwBufSize);
pBufToFree = pBuf;
}
//DWORD dwBufSize = 1024*100;
//char* pBuf = (char*)malloc(dwBufSize);
//char* pBufToFree = pBuf;
DWORD dwBytesRead = 0;
BOOL bRead = FALSE;
do
{
bRead = InternetReadFile(hRequest, pBuf, dwBufSize, &dwBytesRead);
if ( !bRead )
{
m_strErrFunction = L"InternetReadFile";
pNetResp->setResponseCode(408);
break;
}
if (dwBytesRead > 0)
{
if ( pFile )
{
pFile->write(pBuf,dwBytesRead);
pFile->flush();
}
else
pNetResp->getRawData().append(pBuf,dwBytesRead);
}
pNetResp->setValid(true);
}while(bRead && dwBytesRead > 0 && !m_bCancel );
if ( !pNetResp->isOK() )
LOG(TRACE) + "Server response: " + pNetResp->getCharData();
if ( pBufToFree )
free(pBufToFree);
}
void CNetRequestImpl::ErrorMessage(LPCTSTR pszFunction)
{
// Retrieve the system error message for the last-error code
LPTSTR pszMessage = NULL;
DWORD dwLastError = GetLastError();
DWORD dwLen = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
//FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_FROM_HMODULE|
FORMAT_MESSAGE_IGNORE_INSERTS,
GetModuleHandle( _T("wininet.dll") ),
dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&pszMessage,
0, NULL );
wchar_t* szExtError = 0;
if ( dwLastError == ERROR_INTERNET_EXTENDED_ERROR )
{
DWORD dwInetError =0, dwExtLength = 0;
InternetGetLastResponseInfo( &dwInetError, NULL, &dwExtLength );
if ( dwExtLength > 0 )
{
szExtError = (wchar_t*)malloc(sizeof(wchar_t)*(dwExtLength+1));
InternetGetLastResponseInfo( &dwInetError, szExtError, &dwExtLength );
}
}
rho::LogMessage oLogMsg(__FILE__, __LINE__, L_ERROR, LOGCONF(), getLogCategory() );
oLogMsg + "Call " + pszFunction + " failed. Url:" + m_strUrl.c_str() + ". With code : " + dwLastError;
if ( pszMessage )
oLogMsg + ".Message: " + pszMessage;
if ( szExtError && *szExtError )
oLogMsg + ".Extended info: " + szExtError;
if ( szExtError )
free(szExtError);
if ( pszMessage )
LocalFree(pszMessage);
}
void CNetRequestImpl::alloc_url_components(URL_COMPONENTS *uri, const wchar_t *url)
{
int dwLength = wcslen(url)*sizeof(wchar_t);
memset(uri, 0, sizeof(URL_COMPONENTS));
uri->dwStructSize = sizeof(URL_COMPONENTS);
uri->lpszScheme = (LPWSTR)malloc(dwLength);
uri->dwSchemeLength = dwLength;
uri->lpszHostName = (LPWSTR)malloc(dwLength);
uri->dwHostNameLength = dwLength;
uri->lpszUserName = (LPWSTR)malloc(dwLength);
uri->dwUserNameLength = dwLength;
uri->lpszPassword = (LPWSTR)malloc(dwLength);
uri->dwPasswordLength = dwLength;
uri->lpszUrlPath = (LPWSTR)malloc(dwLength);
uri->dwUrlPathLength = dwLength;
uri->lpszExtraInfo = (LPWSTR)malloc(dwLength);
uri->dwExtraInfoLength = dwLength;
}
void CNetRequestImpl::free_url_components(URL_COMPONENTS *uri)
{
if ( uri->lpszScheme )
free(uri->lpszScheme);
if ( uri->lpszHostName )
free(uri->lpszHostName);
if (uri->lpszUserName)
free(uri->lpszUserName);
if (uri->lpszPassword)
free(uri->lpszPassword);
if (uri->lpszUrlPath)
free(uri->lpszUrlPath);
if (uri->lpszExtraInfo)
free(uri->lpszExtraInfo);
}
bool CNetRequestImpl::initConnection(boolean bLocalHost, LPCTSTR url)
{
if (!bLocalHost)
{
common::CMutexLock lock(m_mxInternet);
if ( !SetupInternetConnection(url) )
return false;
}
common::CMutexLock lock(m_mxInternet);
if (m_hInternet)
return true;
if (RHOCONF().isExist("http_proxy_host")) {
rho::String proxyName = RHOCONF().getString("http_proxy_host");
if (RHOCONF().isExist("http_proxy_port")) {
proxyName += ":" + RHOCONF().getString("http_proxy_port");
}
LOG(INFO) + "PROXY: " + proxyName;
m_hInternet = InternetOpen(_T("rhodes-wm"), INTERNET_OPEN_TYPE_PROXY,
rho::common::convertToStringW(proxyName).c_str(),
NULL, NULL);
} else {
m_hInternet = InternetOpen(_T("rhodes-wm"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, NULL );
}
if ( !m_hInternet )
{
m_strErrFunction = L"InternetOpen";
return false;
}
return true;
}
/*static*/void CNetRequestImpl::deinitConnection()
{
common::CMutexLock lock(m_mxInternet);
if (m_hInternet)
InternetCloseHandle(m_hInternet);
m_hInternet = NULL;
#if defined (_WIN32_WCE)&& !defined( OS_PLATFORM_MOTCE )
if ( m_hWceConnMgrConnection )
ConnMgrReleaseConnection(m_hWceConnMgrConnection, FALSE);
m_hWceConnMgrConnection = NULL;
#endif //_WIN32_WCE
}
bool CNetRequestImpl::SetupInternetConnection(LPCTSTR url)
{
#if defined (_WIN32_WCE)&& !defined( OS_PLATFORM_MOTCE )
int iNetwork;
HRESULT hResult = E_FAIL;
DWORD dwStatus;
// cleanup the old connection
if(NULL != m_hWceConnMgrConnection)
{
hResult = ConnMgrConnectionStatus( m_hWceConnMgrConnection, &dwStatus );
if( SUCCEEDED(hResult) )
{
LOG(INFO) + "Internet connection exist, use it";
if( dwStatus & CONNMGR_STATUS_CONNECTED )
return true;
}
ConnMgrReleaseConnection(m_hWceConnMgrConnection, FALSE);
LOG(INFO) + "Internet connection droped, open new one";
m_hWceConnMgrConnection = NULL;
}
// get the right network to connect to
iNetwork = 0;
//CONNMGR_DESTINATION_INFO DestInfo;
GUID pguid;
if( FAILED( ConnMgrMapURL(url, &pguid, NULL) ) )
return false;
//while( SUCCEEDED(ConnMgrEnumDestinations(iNetwork++, &DestInfo)))
{
LOG(INFO) + "Try establish Internet connection";
// actually try to establish the connection
CONNMGR_CONNECTIONINFO ConnInfo;
ZeroMemory(&ConnInfo, sizeof(ConnInfo));
ConnInfo.cbSize = sizeof(ConnInfo);
ConnInfo.dwParams = CONNMGR_PARAM_GUIDDESTNET;
ConnInfo.dwPriority = CONNMGR_PRIORITY_HIPRIBKGND;//CONNMGR_PRIORITY_USERBACKGROUND;
#if ( _WIN32_WCE >= 0x500 )
ConnInfo.dwFlags = CONNMGR_FLAG_NO_ERROR_MSGS;
#endif
ConnInfo.guidDestNet = pguid;
hResult = ConnMgrEstablishConnection(&ConnInfo, &m_hWceConnMgrConnection);
// check to see if the attempt failed
int count = 0;
while(SUCCEEDED(hResult) && count++ < 60 )
{
LOG(INFO) + "Wait for connect (" + count + ")";
DWORD dwResult = WaitForSingleObject(m_hWceConnMgrConnection, 1000);
if (dwResult == (WAIT_OBJECT_0))
{
hResult=ConnMgrConnectionStatus(m_hWceConnMgrConnection,&dwStatus);
if( SUCCEEDED(hResult) )
{
if( dwStatus & CONNMGR_STATUS_CONNECTED )
{
LOG(INFO) + "Connected";
return true;
}
if( dwStatus & CONNMGR_STATUS_WAITINGCONNECTION )
{
continue;
}
break;
}
}
}
}
LOG(ERROR) + "Failed to connect";
return false;
#else
return true;
#endif //_WIN32_WCE
}
}
}
Network: WM: handle connection error
/*------------------------------------------------------------------------
* (The MIT License)
*
* Copyright (c) 2008-2011 Rhomobile, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* http://rhomobile.com
*------------------------------------------------------------------------*/
#include "stdafx.h"
#include "NetRequestImpl.h"
#include "common/RhoFile.h"
#include "common/RhoFilePath.h"
#include "common/RhodesAppBase.h"
#include "common/StringConverter.h"
#include "net/URI.h"
#include "common/RhoConf.h"
#if defined(_WIN32_WCE)&& !defined( OS_PLATFORM_MOTCE )
#include <connmgr.h>
#endif
#ifdef OS_WINCE
extern "C" int strnicmp( const char *s1, const char *s2, size_t count );
#endif
namespace rho {
namespace net {
IMPLEMENT_LOGCLASS(CNetRequestImpl,"Net");
common::CMutex CNetRequestImpl::m_mxInternet;
HINTERNET CNetRequestImpl::m_hInternet;
HANDLE CNetRequestImpl::m_hWceConnMgrConnection;
CNetRequestImpl::CNetRequestImpl()
{
m_hConnection = 0;
m_hRequest = 0;
memset(&m_uri, 0, sizeof(m_uri) );
m_pHeaders = 0;
m_bCancel = false;
m_pSession = 0;
m_sslVerifyPeer = true;
}
void CNetRequestImpl::init(const char* method, const String& strUrl, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
{
m_pHeaders = pHeaders;
m_bCancel = false;
m_pSession = oSession;
m_strErrFunction = L"";
m_hConnection = NULL;
m_hRequest = NULL;
memset(&m_uri, 0, sizeof(m_uri) );
m_strUrl = strUrl;
CAtlStringW strUrlW(strUrl.c_str());
LOG(INFO) + "Method: " + method + ";Url: " + strUrl;
do
{
if ( !initConnection(RHODESAPPBASE().isBaseUrl(strUrl.c_str()), strUrlW) )
break;
DWORD dwUrlLength = 1024;
CAtlStringW strCanonicalUrlW;
if ( !InternetCanonicalizeUrl( strUrlW, strCanonicalUrlW.GetBuffer(dwUrlLength), &dwUrlLength, 0) )
{
m_strErrFunction = _T("InternetCanonicalizeUrl");
break;
}
strCanonicalUrlW.ReleaseBuffer();
alloc_url_components( &m_uri, strCanonicalUrlW );
if( !InternetCrackUrl( strCanonicalUrlW, strCanonicalUrlW.GetLength(), 0, &m_uri ) )
{
m_strErrFunction = L"InternetCrackUrl";
break;
}
m_hConnection = InternetConnect( m_hInternet, m_uri.lpszHostName, m_uri.nPort, _T("anonymous"),
NULL, INTERNET_SERVICE_HTTP, 0, 0 );
if ( !m_hConnection )
{
m_strErrFunction = L"InternetConnect";
break;
}
int timeout = rho_conf_getInt("net_timeout")*1000;
if (timeout == 0 )
timeout = 30000;
InternetSetOption( m_hInternet, INTERNET_OPTION_RECEIVE_TIMEOUT, &timeout, sizeof(timeout) );
m_strReqUrlW = m_uri.lpszUrlPath;
m_strReqUrlW += m_uri.lpszExtraInfo;
DWORD dwFlags = INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_NO_CACHE_WRITE|INTERNET_FLAG_NO_COOKIES|INTERNET_FLAG_NO_AUTO_REDIRECT;
if ( m_uri.lpszScheme && wcsicmp(m_uri.lpszScheme,L"https")==0)
dwFlags |= INTERNET_FLAG_SECURE;
if ( !m_sslVerifyPeer )
dwFlags |= INTERNET_FLAG_IGNORE_CERT_CN_INVALID|INTERNET_FLAG_IGNORE_CERT_DATE_INVALID;
m_hRequest = HttpOpenRequest( m_hConnection, CAtlStringW(method), m_strReqUrlW, NULL, NULL, NULL, dwFlags, NULL );
if ( !m_hRequest )
{
m_strErrFunction = L"HttpOpenRequest";
break;
}
if (oSession!=null)
{
String strSession = oSession->getSession();
LOG(INFO) + "Cookie : " + strSession;
if ( strSession.length() > 0 )
{
String strHeader = "Cookie: " + strSession + "\r\n";
if ( !HttpAddRequestHeaders( m_hRequest, common::convertToStringW(strHeader).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + common::convertToStringW(strHeader);
}
}
if (RHOCONF().isExist("http_proxy_host"))
{
rho::String strLogin, strPassword;
if (RHOCONF().isExist("http_proxy_login"))
strLogin = RHOCONF().getString ("http_proxy_login");
if (RHOCONF().isExist("http_proxy_password"))
strPassword = RHOCONF().getString("http_proxy_password");
if ( strPassword.length() > 0 && strLogin.length() > 0 )
{
String strAuth = strLogin+":"+strPassword;
int nLen = rho_base64_encode(strAuth.c_str(), -1, 0);
char* szBuf = new char[nLen+1];
rho_base64_encode(strAuth.c_str(), -1, szBuf );
String strHeader = "Proxy-Authorization: Basic ";
strHeader += szBuf;
strHeader += "\r\n";
delete szBuf;
if ( !HttpAddRequestHeaders( m_hRequest, common::convertToStringW(strHeader).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + common::convertToStringW(strHeader);
}
}
}while(0);
}
boolean CNetRequestImpl::checkSslCertError()
{
DWORD dwError = GetLastError ();
if (!m_sslVerifyPeer &&(
(dwError == ERROR_INTERNET_INVALID_CA) ||
(dwError == ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED) ||
(dwError == ERROR_INTERNET_SEC_CERT_DATE_INVALID) ||
(dwError == ERROR_INTERNET_SEC_CERT_CN_INVALID)))
{
DWORD dwFlag;
DWORD dwBuffLen = sizeof(dwFlag);
InternetQueryOption (m_hRequest, INTERNET_OPTION_SECURITY_FLAGS,(LPVOID)&dwFlag, &dwBuffLen);
dwFlag |= (SECURITY_FLAG_IGNORE_UNKNOWN_CA
| SECURITY_FLAG_IGNORE_CERT_CN_INVALID
| SECURITY_FLAG_IGNORE_CERT_DATE_INVALID );
InternetSetOption (m_hRequest, INTERNET_OPTION_SECURITY_FLAGS, &dwFlag, sizeof (dwFlag) );
/*
INTERNET_CERTIFICATE_INFO sInfo;
DWORD dwSize = sizeof(sInfo);
if(!InternetQueryOption(m_hSess,INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
&sInfo, &dwSize))
{
dwError = GetLastError();
}
*/
return true;
}
return false;
}
String CNetRequestImpl::getBodyContentType()
{
if ( m_pSession )
return m_pSession->getContentType();
else
return "application/x-www-form-urlencoded";
}
INetResponse* CNetRequestImpl::doRequest( const char* method, const String& strUrl, const String& strBody, IRhoSession* oSession, Hashtable<String,String>* pHeaders )
{
init( method, strUrl, oSession, pHeaders );
CNetResponseImpl* pNetResp = new CNetResponseImpl;
do
{
if ( isError() )
break;
if ( strBody.length() > 0 )
{
CAtlStringW strHeaders = L"Content-Type: ";
strHeaders += getBodyContentType().c_str();
strHeaders += L"\r\n";
if ( !HttpAddRequestHeaders( m_hRequest, strHeaders, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + strHeaders.GetString();
break;
}
}
writeHeaders(m_pHeaders);
if ( isError() )
break;
if ( !HttpSendRequest( m_hRequest, NULL, 0, const_cast<char*>(strBody.c_str()), strBody.length() ) )
{
if (!m_bCancel && checkSslCertError())
{
if ( !HttpSendRequest( m_hRequest, NULL, 0, const_cast<char*>(strBody.c_str()), strBody.length() ) )
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}else
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}
readResponse(pNetResp);
if ( isError() )
break;
readInetFile(m_hRequest,pNetResp);
}while(0);
return pNetResp;
}
void CNetRequestImpl::writeHeaders(Hashtable<String,String>* pHeaders)
{
if ( pHeaders && pHeaders->size() > 0 )
{
String strHeaders;
for ( Hashtable<String,String>::iterator it = pHeaders->begin(); it != pHeaders->end(); ++it )
{
if ( it->first.length() > 0 )
strHeaders += it->first + ":" + (it->second.length() ? it->second : "''") + "\r\n";
}
if ( !HttpAddRequestHeaders( m_hRequest, common::convertToStringW(strHeaders).c_str(), -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + common::convertToStringW(strHeaders);
return;
}
}
}
boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders)
{
oHeaders.clear();
CAtlStringW strHeaders;
DWORD dwLen = 0;
DWORD nIndex = 0;
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, null, &dwLen, &nIndex) )
{
DWORD dwErr = ::GetLastError();
if ( dwErr != ERROR_INSUFFICIENT_BUFFER )
{
m_strErrFunction = L"HttpQueryInfo";
return false;
}
}
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, strHeaders.GetBuffer(dwLen), &dwLen, &nIndex) )
{
m_strErrFunction = L"HttpQueryInfo";
return false;
}
strHeaders.ReleaseBuffer();
int nStart = 0;
for(int nEnd = strHeaders.Find(L"\r\n", nStart); nEnd > 0; nStart = nEnd+2, nEnd = strHeaders.Find(L"\r\n", nStart) )
{
CAtlStringW strHeader = strHeaders.Mid(nStart, nEnd-nStart);
int nSep = strHeader.Find(':');
if (nSep < 0 )
continue;
CAtlStringW strName = strHeader.Mid(0, nSep);
strName.Trim();
strName.MakeLower();
CAtlStringW strValue = strHeader.Mid(nSep+1);
strValue.Trim();
String strFieldName = common::convertToStringA(strName.GetString());
String strFieldValue = common::convertToStringA(strValue.GetString());
LOG(TRACE) + strFieldName + ":" + strFieldValue;
if ( oHeaders.containsKey(strFieldName) )
{
strFieldValue += ";" + oHeaders.get( strFieldName );
oHeaders.put( strFieldName, strFieldValue );
}
else
oHeaders.put( strFieldName, strFieldValue );
}
return true;
}
String CNetRequestImpl::makeClientCookie()
{
DWORD nIndex = 0;
String cookie;
while(true)
{
CAtlStringW strCookie;
DWORD dwLen = 0;
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_SET_COOKIE, null, &dwLen, &nIndex) )
{
DWORD dwErr = ::GetLastError();
if ( dwErr == ERROR_HTTP_HEADER_NOT_FOUND )
break;
if ( dwErr != ERROR_INSUFFICIENT_BUFFER )
{
m_strErrFunction = L"HttpQueryInfo";
break;
}
}
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_SET_COOKIE, strCookie.GetBuffer(dwLen), &dwLen, &nIndex) )
{
m_strErrFunction = L"HttpQueryInfo";
break;
}
strCookie.ReleaseBuffer();
URI::parseCookie(common::convertToStringA(strCookie.GetString()).c_str(), cookie);
}
if ( m_strErrFunction.length() > 0 )
return "";
// if ( cookie.strAuth.length() > 0 || cookie.strSession.length() >0 )
// return cookie.strAuth + ";" + cookie.strSession + ";";
return cookie;
}
void CNetRequestImpl::readResponse(CNetResponseImpl* pNetResp)
{
DWORD dwLen = 10;
wchar_t szHttpRes[10];
DWORD nIndex = 0;
if ( m_bCancel )
return;
if( !HttpQueryInfo( m_hRequest, HTTP_QUERY_STATUS_CODE, szHttpRes, &dwLen, &nIndex) )
{
m_strErrFunction = L"HttpQueryInfo";
return;
}
int nCode = _wtoi(szHttpRes);
pNetResp->setResponseCode(nCode);
if ( m_pHeaders )
{
if ( !readHeaders(*m_pHeaders) )
return;
}
//if ( nCode != 200 && nCode != 206 && nCode != 416 )
if ( nCode >= 400 && nCode != 416 )
{
LOG(ERROR) + "An error occured connecting to the server: " + szHttpRes + " returned.";
// If we're unauthorized, delete any cookies that might have been
// stored so we don't reuse them later
if ( nCode == 401 && m_pSession )
{
LOG(ERROR) + "Unauthorize error.Client will be logged out";
m_pSession->logout();
}
}
if (pNetResp->isSuccess())
pNetResp->setCookies(makeClientCookie());
}
INetResponse* CNetRequestImpl::pullFile(const String& strUrl, common::CRhoFile& oFile, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
{
init("GET", strUrl, oSession, pHeaders);
CNetResponseImpl* pNetResp = new CNetResponseImpl;
const int nDownloadBufferSize = 1024*100;
char* pDownloadBuffer = 0;
do
{
writeHeaders(m_pHeaders);
if ( isError() )
break;
if ( oFile.size() > 0 )
{
CAtlStringW strHeaders = L"Range: bytes=";
strHeaders += common::convertToStringW(oFile.size()).c_str();
strHeaders += L"-";
//strHeaders += common::convertToStringW(oFile.size()+30068032).c_str();
strHeaders += "\r\n";
if ( !HttpAddRequestHeaders( m_hRequest, strHeaders, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + strHeaders.GetString();
break;
}
}
if ( !HttpSendRequest( m_hRequest, NULL, 0, NULL, 0 ) )
{
if (!m_bCancel && checkSslCertError())
{
if ( !HttpSendRequest( m_hRequest, NULL, 0, NULL, 0 ) )
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}else
{
m_strErrFunction = L"HttpSendRequest";
break;
}
}
readResponse(pNetResp);
if ( isError() )
break;
if ( pNetResp->getRespCode() == 200 )
oFile.movePosToStart();
if ( pNetResp->getRespCode() == 416 )
{
pNetResp->setResponseCode(206);
break;
}
if ( pNetResp->isOK() )
{
if (!pDownloadBuffer)
pDownloadBuffer = new char[nDownloadBufferSize];
readInetFile(m_hRequest,pNetResp, &oFile, pDownloadBuffer, nDownloadBufferSize);
}else
readInetFile(m_hRequest,pNetResp);
}while(0);
if (pDownloadBuffer)
delete pDownloadBuffer;
return pNetResp;
}
static const wchar_t* szMultipartContType =
L"Content-Type: multipart/form-data; boundary=----------A6174410D6AD474183FDE48F5662FCC5\r\n";
static const char* szMultipartPostfix =
"\r\n------------A6174410D6AD474183FDE48F5662FCC5--";
int CNetRequestImpl::processMultipartItems( VectorPtr<CMultipartItem*>& arItems )
{
int nSize = 0;
for( int i = 0; i < (int)arItems.size(); i++ )
{
CMultipartItem& oItem = *arItems.elementAt(i);
if ( oItem.m_strName.length() == 0 )
oItem.m_strName = "blob";
if ( oItem.m_strFileName.length() == 0 )
{
if ( oItem.m_strFilePath.length() > 0 )
{
common::CFilePath oPath(oItem.m_strFilePath);
oItem.m_strFileName = oPath.getBaseName();
}
//else
// oItem.m_strFileName = "doesnotmatter.txt";
}
oItem.m_strDataPrefix = i > 0 ? "\r\n" : "";
oItem.m_strDataPrefix +=
"------------A6174410D6AD474183FDE48F5662FCC5\r\n"
"Content-Disposition: form-data; name=\"";
oItem.m_strDataPrefix += oItem.m_strName + "\"";
if (oItem.m_strFileName.length()>0)
oItem.m_strDataPrefix += "; filename=\"" + oItem.m_strFileName + "\"";
oItem.m_strDataPrefix += "\r\n";
if ( oItem.m_strContentType.length() > 0 )
oItem.m_strDataPrefix += "Content-Type: " + oItem.m_strContentType + "\r\n";
int nContentSize = 0;
if ( oItem.m_strFilePath.length() > 0 )
{
common::CRhoFile oFile;
if ( oFile.open(oItem.m_strFilePath.c_str(),common::CRhoFile::OpenReadOnly) )
nContentSize = oFile.size();
}
else
nContentSize = oItem.m_strBody.length();
if ( oItem.m_strContentType.length() > 0 )
oItem.m_strDataPrefix += "Content-Length: " + common::convertToStringA(nContentSize) + "\r\n";
oItem.m_strDataPrefix += "\r\n";
nSize += oItem.m_strDataPrefix.length() + nContentSize;
}
nSize += strlen(szMultipartPostfix);
return nSize;
}
INetResponse* CNetRequestImpl::pushMultipartData(const String& strUrl, VectorPtr<CMultipartItem*>& arItems, IRhoSession* oSession, Hashtable<String,String>* pHeaders)
{
init("POST", strUrl, oSession, pHeaders );
CNetResponseImpl* pNetResp = new CNetResponseImpl;
do
{
writeHeaders(m_pHeaders);
if ( isError() )
break;
if ( !HttpAddRequestHeaders( m_hRequest, szMultipartContType, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE ) )
{
m_strErrFunction = StringW(L"HttpAddRequestHeaders:") + szMultipartContType;
break;
}
INTERNET_BUFFERS BufferIn;
memset(&BufferIn, 0, sizeof(INTERNET_BUFFERS));
BufferIn.dwStructSize = sizeof( INTERNET_BUFFERS ); // Must be set or error will occur
BufferIn.dwBufferTotal = processMultipartItems( arItems );
if(!HttpSendRequestEx( m_hRequest, &BufferIn, NULL, 0, 0))
{
if (checkSslCertError())
{
if(!HttpSendRequestEx( m_hRequest, &BufferIn, NULL, 0, 0))
{
m_strErrFunction = L"HttpSendRequestEx";
break;
}
}else
{
m_strErrFunction = L"HttpSendRequestEx";
break;
}
}
//write all items
for( int i = 0; i < (int)arItems.size(); i++ )
{
CMultipartItem& oItem = *arItems.elementAt(i);
if ( oItem.m_strFilePath.length() > 0 )
{
common::CRhoFile oFile;
if ( !oFile.open(oItem.m_strFilePath.c_str(),common::CRhoFile::OpenReadOnly) )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
common::InputStream* bodyStream = oFile.getInputStream();
if ( !internetWriteHeader( oItem.m_strDataPrefix.c_str(), "", "") )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
DWORD dwBytesWritten = 0;
if ( bodyStream->available() > 0 )
{
DWORD dwBufSize = 4096;
char* pBuf = (char*)malloc(dwBufSize);
int nReaded = 0;
do
{
nReaded = bodyStream->read(pBuf,0,dwBufSize);
if ( nReaded > 0 )
{
if ( !InternetWriteFile( m_hRequest, pBuf, nReaded, &dwBytesWritten) )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
}
}while(nReaded > 0);
free(pBuf);
}
}else
{
if ( !internetWriteHeader( oItem.m_strDataPrefix.c_str(), oItem.m_strBody.c_str(), "") )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
}
}
if ( !internetWriteHeader( "", "", szMultipartPostfix) )
{
m_strErrFunction = L"InternetWriteFile";
return pNetResp;
}
if ( !HttpEndRequest(m_hRequest, NULL, 0, 0) )
{
m_strErrFunction = L"HttpEndRequest";
break;
}
if ( isError() )
break;
readResponse(pNetResp);
if ( isError() )
break;
readInetFile(m_hRequest,pNetResp);
}while(0);
return pNetResp;
}
bool CNetRequestImpl::internetWriteHeader( const char* szPrefix, const char* szBody, const char* szPrefixEnd)
{
DWORD dwBytesWritten = 0;
if ( szPrefix && *szPrefix && !InternetWriteFile( m_hRequest, szPrefix, strlen(szPrefix), &dwBytesWritten) )
return false;
if ( szBody && *szBody && !InternetWriteFile( m_hRequest, szBody, strlen(szBody), &dwBytesWritten) )
return false;
if ( szPrefixEnd && *szPrefixEnd && !InternetWriteFile( m_hRequest, szPrefixEnd, strlen(szPrefixEnd), &dwBytesWritten) )
return false;
return true;
}
void CNetRequestImpl::cancel()
{
m_bCancel = true;
if ( m_hRequest )
InternetCloseHandle(m_hRequest);
if ( m_hConnection )
InternetCloseHandle(m_hConnection);
/* if ( hInet )
InternetCloseHandle(hInet); */
/*
hRequest = 0;
hConnection = 0;
hInet = 0;*/
}
void CNetRequestImpl::close()
{
if (!m_bCancel && m_strErrFunction.length()>0)
ErrorMessage(m_strErrFunction.c_str());
free_url_components(&m_uri);
if ( m_hRequest )
InternetCloseHandle(m_hRequest);
if ( m_hConnection )
InternetCloseHandle(m_hConnection);
// if ( hInet )
// InternetCloseHandle(hInet);
memset(&m_uri, 0, sizeof(m_uri));
m_hRequest = 0;
m_hConnection = 0;
// hInet = 0;
}
CNetRequestImpl::~CNetRequestImpl()
{
close();
}
void CNetRequestImpl::readInetFile( HINTERNET hRequest, CNetResponseImpl* pNetResp, common::CRhoFile* pFile /*=NULL*/,
char* pBuf, DWORD dwBufSize )
{
if (m_bCancel)
return;
//if ( pNetResp->getRespCode() == 500 || pNetResp->getRespCode() == 422 )
// return;
char* pBufToFree = 0;
if (!pBuf)
{
if ( dwBufSize==0)
dwBufSize=1024*50;
pBuf = (char*)malloc(dwBufSize);
pBufToFree = pBuf;
}
//DWORD dwBufSize = 1024*100;
//char* pBuf = (char*)malloc(dwBufSize);
//char* pBufToFree = pBuf;
DWORD dwBytesRead = 0;
BOOL bRead = FALSE;
do
{
bRead = InternetReadFile(hRequest, pBuf, dwBufSize, &dwBytesRead);
if ( !bRead )
{
m_strErrFunction = L"InternetReadFile";
pNetResp->setResponseCode(408);
break;
}
if (dwBytesRead > 0)
{
if ( pFile )
{
pFile->write(pBuf,dwBytesRead);
pFile->flush();
}
else
pNetResp->getRawData().append(pBuf,dwBytesRead);
}
pNetResp->setValid(true);
}while(bRead && dwBytesRead > 0 && !m_bCancel );
if ( !pNetResp->isOK() )
LOG(TRACE) + "Server response: " + pNetResp->getCharData();
if ( pBufToFree )
free(pBufToFree);
}
void CNetRequestImpl::ErrorMessage(LPCTSTR pszFunction)
{
// Retrieve the system error message for the last-error code
LPTSTR pszMessage = NULL;
DWORD dwLastError = GetLastError();
DWORD dwLen = FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
//FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_FROM_HMODULE|
FORMAT_MESSAGE_IGNORE_INSERTS,
GetModuleHandle( _T("wininet.dll") ),
dwLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&pszMessage,
0, NULL );
wchar_t* szExtError = 0;
if ( dwLastError == ERROR_INTERNET_EXTENDED_ERROR )
{
DWORD dwInetError =0, dwExtLength = 0;
InternetGetLastResponseInfo( &dwInetError, NULL, &dwExtLength );
if ( dwExtLength > 0 )
{
szExtError = (wchar_t*)malloc(sizeof(wchar_t)*(dwExtLength+1));
InternetGetLastResponseInfo( &dwInetError, szExtError, &dwExtLength );
}
}
rho::LogMessage oLogMsg(__FILE__, __LINE__, L_ERROR, LOGCONF(), getLogCategory() );
oLogMsg + "Call " + pszFunction + " failed. Url:" + m_strUrl.c_str() + ". With code : " + dwLastError;
if ( pszMessage )
oLogMsg + ".Message: " + pszMessage;
if ( szExtError && *szExtError )
oLogMsg + ".Extended info: " + szExtError;
if ( szExtError )
free(szExtError);
if ( pszMessage )
LocalFree(pszMessage);
}
void CNetRequestImpl::alloc_url_components(URL_COMPONENTS *uri, const wchar_t *url)
{
int dwLength = wcslen(url)*sizeof(wchar_t);
memset(uri, 0, sizeof(URL_COMPONENTS));
uri->dwStructSize = sizeof(URL_COMPONENTS);
uri->lpszScheme = (LPWSTR)malloc(dwLength);
uri->dwSchemeLength = dwLength;
uri->lpszHostName = (LPWSTR)malloc(dwLength);
uri->dwHostNameLength = dwLength;
uri->lpszUserName = (LPWSTR)malloc(dwLength);
uri->dwUserNameLength = dwLength;
uri->lpszPassword = (LPWSTR)malloc(dwLength);
uri->dwPasswordLength = dwLength;
uri->lpszUrlPath = (LPWSTR)malloc(dwLength);
uri->dwUrlPathLength = dwLength;
uri->lpszExtraInfo = (LPWSTR)malloc(dwLength);
uri->dwExtraInfoLength = dwLength;
}
void CNetRequestImpl::free_url_components(URL_COMPONENTS *uri)
{
if ( uri->lpszScheme )
free(uri->lpszScheme);
if ( uri->lpszHostName )
free(uri->lpszHostName);
if (uri->lpszUserName)
free(uri->lpszUserName);
if (uri->lpszPassword)
free(uri->lpszPassword);
if (uri->lpszUrlPath)
free(uri->lpszUrlPath);
if (uri->lpszExtraInfo)
free(uri->lpszExtraInfo);
}
bool CNetRequestImpl::initConnection(boolean bLocalHost, LPCTSTR url)
{
if (!bLocalHost)
{
common::CMutexLock lock(m_mxInternet);
if ( !SetupInternetConnection(url) )
return false;
}
common::CMutexLock lock(m_mxInternet);
if (m_hInternet)
return true;
if (RHOCONF().isExist("http_proxy_host")) {
rho::String proxyName = RHOCONF().getString("http_proxy_host");
if (RHOCONF().isExist("http_proxy_port")) {
proxyName += ":" + RHOCONF().getString("http_proxy_port");
}
LOG(INFO) + "PROXY: " + proxyName;
m_hInternet = InternetOpen(_T("rhodes-wm"), INTERNET_OPEN_TYPE_PROXY,
rho::common::convertToStringW(proxyName).c_str(),
NULL, NULL);
} else {
m_hInternet = InternetOpen(_T("rhodes-wm"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, NULL );
}
if ( !m_hInternet )
{
m_strErrFunction = L"InternetOpen";
return false;
}
return true;
}
/*static*/void CNetRequestImpl::deinitConnection()
{
common::CMutexLock lock(m_mxInternet);
if (m_hInternet)
InternetCloseHandle(m_hInternet);
m_hInternet = NULL;
#if defined (_WIN32_WCE)&& !defined( OS_PLATFORM_MOTCE )
if ( m_hWceConnMgrConnection )
ConnMgrReleaseConnection(m_hWceConnMgrConnection, FALSE);
m_hWceConnMgrConnection = NULL;
#endif //_WIN32_WCE
}
bool CNetRequestImpl::SetupInternetConnection(LPCTSTR url)
{
#if defined (_WIN32_WCE)&& !defined( OS_PLATFORM_MOTCE )
int iNetwork;
HRESULT hResult = E_FAIL;
DWORD dwStatus;
// cleanup the old connection
if(NULL != m_hWceConnMgrConnection)
{
hResult = ConnMgrConnectionStatus( m_hWceConnMgrConnection, &dwStatus );
if( SUCCEEDED(hResult) )
{
LOG(INFO) + "Internet connection exist, use it";
if( dwStatus & CONNMGR_STATUS_CONNECTED )
return true;
}
ConnMgrReleaseConnection(m_hWceConnMgrConnection, FALSE);
LOG(INFO) + "Internet connection droped, open new one";
m_hWceConnMgrConnection = NULL;
}
// get the right network to connect to
iNetwork = 0;
//CONNMGR_DESTINATION_INFO DestInfo;
GUID pguid;
if( FAILED( ConnMgrMapURL(url, &pguid, NULL) ) )
return false;
//while( SUCCEEDED(ConnMgrEnumDestinations(iNetwork++, &DestInfo)))
{
LOG(INFO) + "Try establish Internet connection";
// actually try to establish the connection
CONNMGR_CONNECTIONINFO ConnInfo;
ZeroMemory(&ConnInfo, sizeof(ConnInfo));
ConnInfo.cbSize = sizeof(ConnInfo);
ConnInfo.dwParams = CONNMGR_PARAM_GUIDDESTNET;
ConnInfo.dwPriority = CONNMGR_PRIORITY_HIPRIBKGND;//CONNMGR_PRIORITY_USERBACKGROUND;
#if ( _WIN32_WCE >= 0x500 )
ConnInfo.dwFlags = CONNMGR_FLAG_NO_ERROR_MSGS;
#endif
ConnInfo.guidDestNet = pguid;
hResult = ConnMgrEstablishConnection(&ConnInfo, &m_hWceConnMgrConnection);
// check to see if the attempt failed
int count = 0;
while(SUCCEEDED(hResult) && count++ < 60 )
{
LOG(INFO) + "Wait for connect (" + count + ")";
DWORD dwResult = WaitForSingleObject(m_hWceConnMgrConnection, 1000);
if (dwResult == (WAIT_OBJECT_0))
{
hResult=ConnMgrConnectionStatus(m_hWceConnMgrConnection,&dwStatus);
if( SUCCEEDED(hResult) )
{
if( dwStatus & CONNMGR_STATUS_CONNECTED )
{
LOG(INFO) + "Connected";
return true;
}
if( dwStatus & CONNMGR_STATUS_WAITINGCONNECTION )
{
continue;
}
break;
}
}
}
}
LOG(ERROR) + "Failed to connect";
m_strErrFunction = L"ConnMgrConnectionStatus";
return false;
#else
return true;
#endif //_WIN32_WCE
}
}
}
|
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/common/include/p9_frequency_buckets.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
// constant defining number of NEST PLL frequency options ('buckets')
// to be built into unsigned HW image
const uint8_t NEST_PLL_FREQ_BUCKETS = 5;
// Nest PLL frequency in MHZ
// index is bucket number
const uint32_t NEST_PLL_FREQ_LIST[NEST_PLL_FREQ_BUCKETS] =
{
1600,
1866,
2000,
2133,
2400
};
// I2C bus divisor
// index is bucket number
// The values in this list will be factor of 1:64 to the NEST_PLL_FREQ_LIST
const uint32_t NEST_PLL_FREQ_I2CDIV_LIST[NEST_PLL_FREQ_BUCKETS] =
{
25,
29,
31,
33,
37
};
// constant defining number of MEM PLL frequency options ('buckets')
// to be built into unsigned HW image
const uint8_t MEM_PLL_FREQ_BUCKETS = 5;
// MEM PLL frequency in MHz
// index is bucket number
const uint32_t MEM_PLL_FREQ_LIST[MEM_PLL_FREQ_BUCKETS] =
{
1866,
2133,
2400,
2666,
2666
};
// constant definining number of OBUS PLL frequency options ('buckets')
// to be built into unsigned HW image
const uint8_t OBUS_PLL_FREQ_BUCKETS = 3;
// OBUS PLL frequency in MHz
// index is bucket number
const uint32_t OBUS_PLL_FREQ_LIST_P9N_10[OBUS_PLL_FREQ_BUCKETS] =
{
1250,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9N_20[OBUS_PLL_FREQ_BUCKETS] =
{
1563,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9N_21[OBUS_PLL_FREQ_BUCKETS] =
{
1563,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9N_22[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1563
};
const uint32_t OBUS_PLL_FREQ_LIST_P9C_10[OBUS_PLL_FREQ_BUCKETS] =
{
1601,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9C_11[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1601
};
const uint32_t OBUS_PLL_FREQ_LIST_P9A_10[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9A_11[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1611
};
Add support for p9c 1.2
Also initial mk files for p9n 2.3, but p9c 1.2 will be first.
Change-Id: Ia73aba37be5bcf64b1b2cfe5b1ed153b189c7777
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/53909
Tested-by: FSP CI Jenkins <aa9e4d9ac7cd25905e9c0dd36d4150516e73dd86@us.ibm.com>
Tested-by: Jenkins Server <8e3f934e4c44875bc48d33da3ea13d93ba9a233f@us.ibm.com>
Tested-by: HWSV CI <ae069ce3805842f4ed79e0ef7868baadb5df0a6b@us.ibm.com>
Tested-by: PPE CI <dc75934ba5befb9221434e67a247b93aec46b36b@us.ibm.com>
Tested-by: Hostboot CI <52521565bd8ea18a2b112942dce4f4220a97c2c8@us.ibm.com>
Reviewed-by: Joseph J. McGill <4a85c6614f9f065f63d8fd57cde15e48af07ea2a@us.ibm.com>
Reviewed-by: James N. Klazynski <5a5e585153ad1c2ad260ff53cd311cb91d2f96be@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <ab93eca12e43608f33daa16a67357cd7b7e867ab@us.ibm.com>
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/common/include/p9_frequency_buckets.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
// constant defining number of NEST PLL frequency options ('buckets')
// to be built into unsigned HW image
const uint8_t NEST_PLL_FREQ_BUCKETS = 5;
// Nest PLL frequency in MHZ
// index is bucket number
const uint32_t NEST_PLL_FREQ_LIST[NEST_PLL_FREQ_BUCKETS] =
{
1600,
1866,
2000,
2133,
2400
};
// I2C bus divisor
// index is bucket number
// The values in this list will be factor of 1:64 to the NEST_PLL_FREQ_LIST
const uint32_t NEST_PLL_FREQ_I2CDIV_LIST[NEST_PLL_FREQ_BUCKETS] =
{
25,
29,
31,
33,
37
};
// constant defining number of MEM PLL frequency options ('buckets')
// to be built into unsigned HW image
const uint8_t MEM_PLL_FREQ_BUCKETS = 5;
// MEM PLL frequency in MHz
// index is bucket number
const uint32_t MEM_PLL_FREQ_LIST[MEM_PLL_FREQ_BUCKETS] =
{
1866,
2133,
2400,
2666,
2666
};
// constant definining number of OBUS PLL frequency options ('buckets')
// to be built into unsigned HW image
const uint8_t OBUS_PLL_FREQ_BUCKETS = 3;
// OBUS PLL frequency in MHz
// index is bucket number
const uint32_t OBUS_PLL_FREQ_LIST_P9N_10[OBUS_PLL_FREQ_BUCKETS] =
{
1250,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9N_20[OBUS_PLL_FREQ_BUCKETS] =
{
1563,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9N_21[OBUS_PLL_FREQ_BUCKETS] =
{
1563,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9N_22[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1563
};
const uint32_t OBUS_PLL_FREQ_LIST_P9C_10[OBUS_PLL_FREQ_BUCKETS] =
{
1601,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9C_11[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1601
};
const uint32_t OBUS_PLL_FREQ_LIST_P9C_12[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1601
};
const uint32_t OBUS_PLL_FREQ_LIST_P9A_10[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1611
};
const uint32_t OBUS_PLL_FREQ_LIST_P9A_11[OBUS_PLL_FREQ_BUCKETS] =
{
1611,
1250,
1611
};
|
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/initfiles/p9_nx_scom.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
#include "p9_nx_scom.H"
#include <stdint.h>
#include <stddef.h>
#include <fapi2.H>
using namespace fapi2;
constexpr uint64_t literal_1 = 1;
constexpr uint64_t literal_0b0 = 0b0;
constexpr uint64_t literal_0b1 = 0b1;
constexpr uint64_t literal_0b11 = 0b11;
constexpr uint64_t literal_0b00 = 0b00;
constexpr uint64_t literal_0 = 0;
constexpr uint64_t literal_0xFC = 0xFC;
constexpr uint64_t literal_8 = 8;
constexpr uint64_t literal_2 = 2;
constexpr uint64_t literal_0b111111 = 0b111111;
constexpr uint64_t literal_0b11111111 = 0b11111111;
constexpr uint64_t literal_0b000000 = 0b000000;
constexpr uint64_t literal_0b00000000 = 0b00000000;
fapi2::ReturnCode p9_nx_scom(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& TGT0,
const fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>& TGT1)
{
{
fapi2::ATTR_EC_Type l_chip_ec;
fapi2::ATTR_NAME_Type l_chip_id;
FAPI_TRY(FAPI_ATTR_GET_PRIVILEGED(fapi2::ATTR_NAME, TGT0, l_chip_id));
FAPI_TRY(FAPI_ATTR_GET_PRIVILEGED(fapi2::ATTR_EC, TGT0, l_chip_ec));
fapi2::ATTR_CHIP_EC_FEATURE_HW403701_Type l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_EC_FEATURE_HW403701, TGT0, l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701));
fapi2::ATTR_CHIP_EC_FEATURE_HW414700_Type l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_EC_FEATURE_HW414700, TGT0, l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700));
fapi2::ATTR_PROC_FABRIC_PUMP_MODE_Type l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_PROC_FABRIC_PUMP_MODE, TGT1, l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE));
fapi2::ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID_Type l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID, TGT1, l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID));
fapi2::ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID_Type l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID, TGT1, l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID));
fapi2::buffer<uint64_t> l_scom_buffer;
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011041ull, l_scom_buffer ));
constexpr auto l_NX_DMA_CH0_EFT_ENABLE_ON = 0x1;
l_scom_buffer.insert<63, 1, 63, uint64_t>(l_NX_DMA_CH0_EFT_ENABLE_ON );
constexpr auto l_NX_DMA_CH1_EFT_ENABLE_ON = 0x1;
l_scom_buffer.insert<62, 1, 63, uint64_t>(l_NX_DMA_CH1_EFT_ENABLE_ON );
constexpr auto l_NX_DMA_CH2_SYM_ENABLE_ON = 0x1;
l_scom_buffer.insert<58, 1, 63, uint64_t>(l_NX_DMA_CH2_SYM_ENABLE_ON );
constexpr auto l_NX_DMA_CH3_SYM_ENABLE_ON = 0x1;
l_scom_buffer.insert<57, 1, 63, uint64_t>(l_NX_DMA_CH3_SYM_ENABLE_ON );
constexpr auto l_NX_DMA_CH4_GZIP_ENABLE_ON = 0x1;
l_scom_buffer.insert<61, 1, 63, uint64_t>(l_NX_DMA_CH4_GZIP_ENABLE_ON );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011041ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011042ull, l_scom_buffer ));
constexpr auto l_NX_DMA_EFTCOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<33, 4, 60, uint64_t>(l_NX_DMA_EFTCOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_EFTDECOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<37, 4, 60, uint64_t>(l_NX_DMA_EFTDECOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_GZIPCOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<8, 4, 60, uint64_t>(l_NX_DMA_GZIPCOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_GZIPDECOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<12, 4, 60, uint64_t>(l_NX_DMA_GZIPDECOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_SYM_MAX_INRD_MAX_3_INRD = 0x3;
l_scom_buffer.insert<25, 4, 60, uint64_t>(l_NX_DMA_SYM_MAX_INRD_MAX_3_INRD );
if (((l_chip_id == 0x5) && (l_chip_ec == 0x10)) )
{
constexpr auto l_NX_DMA_SYM_CPB_CHECK_DISABLE_ON = 0x1;
l_scom_buffer.insert<48, 1, 63, uint64_t>(l_NX_DMA_SYM_CPB_CHECK_DISABLE_ON );
}
constexpr auto l_NX_DMA_EFT_COMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<23, 1, 63, uint64_t>(l_NX_DMA_EFT_COMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_EFT_DECOMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<24, 1, 63, uint64_t>(l_NX_DMA_EFT_DECOMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_GZIP_COMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<16, 1, 63, uint64_t>(l_NX_DMA_GZIP_COMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_GZIP_DECOMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<17, 1, 63, uint64_t>(l_NX_DMA_GZIP_DECOMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_EFT_SPBC_WRITE_ENABLE_OFF = 0x0;
l_scom_buffer.insert<56, 1, 63, uint64_t>(l_NX_DMA_EFT_SPBC_WRITE_ENABLE_OFF );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011042ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x201105cull, l_scom_buffer ));
constexpr auto l_NX_DMA_CH0_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<1, 4, 60, uint64_t>(l_NX_DMA_CH0_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH0_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<0, 1, 63, uint64_t>(l_NX_DMA_CH0_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH1_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<6, 4, 60, uint64_t>(l_NX_DMA_CH1_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH1_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<5, 1, 63, uint64_t>(l_NX_DMA_CH1_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH2_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<11, 4, 60, uint64_t>(l_NX_DMA_CH2_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH2_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<10, 1, 63, uint64_t>(l_NX_DMA_CH2_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH3_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<16, 4, 60, uint64_t>(l_NX_DMA_CH3_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH3_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<15, 1, 63, uint64_t>(l_NX_DMA_CH3_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH4_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<21, 4, 60, uint64_t>(l_NX_DMA_CH4_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH4_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<20, 1, 63, uint64_t>(l_NX_DMA_CH4_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_DMA_HANG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<25, 1, 63, uint64_t>(l_NX_DMA_DMA_HANG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_DMA_HANG_TIMER_REF_DIV_DIVIDE_BY_1024 = 0x8;
l_scom_buffer.insert<26, 4, 60, uint64_t>(l_NX_DMA_DMA_HANG_TIMER_REF_DIV_DIVIDE_BY_1024 );
FAPI_TRY(fapi2::putScom(TGT0, 0x201105cull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011083ull, l_scom_buffer ));
if (literal_1)
{
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<25, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<26, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<27, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<28, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<29, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<30, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 == literal_1))
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b1 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 != literal_1))
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 == literal_1))
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b1 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 != literal_1))
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<3, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<40, 2, 62, uint64_t>(literal_0b11 );
}
if (literal_1)
{
l_scom_buffer.insert<42, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<43, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
}
FAPI_TRY(fapi2::putScom(TGT0, 0x2011083ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011086ull, l_scom_buffer ));
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<25, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<26, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<27, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<28, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<29, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<30, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<3, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<40, 2, 62, uint64_t>(literal_0b00 );
l_scom_buffer.insert<42, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<43, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011086ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011087ull, l_scom_buffer ));
if (literal_1)
{
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<25, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<26, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<27, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<28, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<29, 1, 63, uint64_t>(literal_0b0 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<30, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<3, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<40, 2, 62, uint64_t>(literal_0b00 );
}
if (literal_1)
{
l_scom_buffer.insert<42, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<43, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
}
FAPI_TRY(fapi2::putScom(TGT0, 0x2011087ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011095ull, l_scom_buffer ));
if ((l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE == fapi2::ENUM_ATTR_PROC_FABRIC_PUMP_MODE_CHIP_IS_GROUP))
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_ON = 0x1;
l_scom_buffer.insert<24, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_ON );
}
else if ((l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE == fapi2::ENUM_ATTR_PROC_FABRIC_PUMP_MODE_CHIP_IS_NODE))
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_OFF = 0x0;
l_scom_buffer.insert<24, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_OFF );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x21)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x22)) || ((l_chip_id == 0x6) && (l_chip_ec == 0x10)) || ((l_chip_id == 0x6) && (l_chip_ec == 0x11))
|| ((l_chip_id == 0x6) && (l_chip_ec == 0x12)) )
{
l_scom_buffer.insert<56, 4, 60, uint64_t>(l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID );
l_scom_buffer.insert<60, 3, 61, uint64_t>(l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<1, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<5, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<9, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<13, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<2, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_VG_NOT_SYS_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<6, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_VG_NOT_SYS_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<10, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_VG_NOT_SYS_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<14, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_VG_NOT_SYS_ON );
}
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_RD_GO_M_QOS_ON = 0x1;
l_scom_buffer.insert<22, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_RD_GO_M_QOS_ON );
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_ADDR_BAR_MODE_OFF = 0x0;
l_scom_buffer.insert<23, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_ADDR_BAR_MODE_OFF );
l_scom_buffer.insert<25, 2, 62, uint64_t>(literal_1 );
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0xFC );
l_scom_buffer.insert<48, 8, 56, uint64_t>(literal_0xFC );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011095ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110a8ull, l_scom_buffer ));
l_scom_buffer.insert<8, 4, 60, uint64_t>(literal_8 );
l_scom_buffer.insert<4, 4, 60, uint64_t>(literal_8 );
l_scom_buffer.insert<12, 4, 60, uint64_t>(literal_8 );
l_scom_buffer.insert<16, 4, 60, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110a8ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110c3ull, l_scom_buffer ));
l_scom_buffer.insert<27, 9, 55, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110c3ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110c4ull, l_scom_buffer ));
l_scom_buffer.insert<27, 9, 55, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110c4ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110c5ull, l_scom_buffer ));
l_scom_buffer.insert<27, 9, 55, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110c5ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110d5ull, l_scom_buffer ));
constexpr auto l_NX_PBI_PBI_UMAC_CRB_READS_ENBL_ON = 0x1;
l_scom_buffer.insert<1, 1, 63, uint64_t>(l_NX_PBI_PBI_UMAC_CRB_READS_ENBL_ON );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110d5ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110d6ull, l_scom_buffer ));
l_scom_buffer.insert<9, 3, 61, uint64_t>(literal_2 );
constexpr auto l_NX_PBI_DISABLE_PROMOTE_ON = 0x1;
l_scom_buffer.insert<6, 1, 63, uint64_t>(l_NX_PBI_DISABLE_PROMOTE_ON );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110d6ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011103ull, l_scom_buffer ));
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<25, 6, 58, uint64_t>(literal_0b111111 );
l_scom_buffer.insert<2, 2, 62, uint64_t>(literal_0b11 );
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0b11111111 );
l_scom_buffer.insert<48, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<49, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011103ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011106ull, l_scom_buffer ));
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<25, 6, 58, uint64_t>(literal_0b000000 );
l_scom_buffer.insert<2, 2, 62, uint64_t>(literal_0b00 );
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0b00000000 );
l_scom_buffer.insert<48, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<49, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011106ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011107ull, l_scom_buffer ));
if (literal_1)
{
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<25, 6, 58, uint64_t>(literal_0b000000 );
}
if (literal_1)
{
l_scom_buffer.insert<2, 2, 62, uint64_t>(literal_0b00 );
}
if (literal_1)
{
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0b00000000 );
}
if (literal_1)
{
l_scom_buffer.insert<48, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<49, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b1 );
}
FAPI_TRY(fapi2::putScom(TGT0, 0x2011107ull, l_scom_buffer));
}
};
fapi_try_exit:
return fapi2::current_err;
}
Adding p9n 2.3 support and p9n 2.3/p9c 1.2 security update
CMVC-Prereq: 1051830
Change-Id: Ib978c044d92dc6e6a9e22e22f0e0cab3a07b5034
Original-Change-Id: I21b0d9187443f2727f83df310bca2fb3ae0fd80c
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/55376
Dev-Ready: Matt K. Light <19ba8ed73a0b3c376c81fced381f1ac0f483b7c2@us.ibm.com>
Tested-by: Jenkins Server <8e3f934e4c44875bc48d33da3ea13d93ba9a233f@us.ibm.com>
Tested-by: HWSV CI <ae069ce3805842f4ed79e0ef7868baadb5df0a6b@us.ibm.com>
Tested-by: PPE CI <dc75934ba5befb9221434e67a247b93aec46b36b@us.ibm.com>
Tested-by: Hostboot CI <52521565bd8ea18a2b112942dce4f4220a97c2c8@us.ibm.com>
Tested-by: FSP CI Jenkins <aa9e4d9ac7cd25905e9c0dd36d4150516e73dd86@us.ibm.com>
Reviewed-by: Soma Bhanutej <92c79b5945b50481db2fb6f073a7397943fceb73@in.ibm.com>
Reviewed-by: Jennifer A. Stofer <ab93eca12e43608f33daa16a67357cd7b7e867ab@us.ibm.com>
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/initfiles/p9_nx_scom.C $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2016,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
#include "p9_nx_scom.H"
#include <stdint.h>
#include <stddef.h>
#include <fapi2.H>
using namespace fapi2;
constexpr uint64_t literal_1 = 1;
constexpr uint64_t literal_0b0 = 0b0;
constexpr uint64_t literal_0b1 = 0b1;
constexpr uint64_t literal_0b11 = 0b11;
constexpr uint64_t literal_0b00 = 0b00;
constexpr uint64_t literal_0 = 0;
constexpr uint64_t literal_0xFC = 0xFC;
constexpr uint64_t literal_8 = 8;
constexpr uint64_t literal_2 = 2;
constexpr uint64_t literal_0b111111 = 0b111111;
constexpr uint64_t literal_0b11111111 = 0b11111111;
constexpr uint64_t literal_0b000000 = 0b000000;
constexpr uint64_t literal_0b00000000 = 0b00000000;
fapi2::ReturnCode p9_nx_scom(const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& TGT0,
const fapi2::Target<fapi2::TARGET_TYPE_SYSTEM>& TGT1)
{
{
fapi2::ATTR_EC_Type l_chip_ec;
fapi2::ATTR_NAME_Type l_chip_id;
FAPI_TRY(FAPI_ATTR_GET_PRIVILEGED(fapi2::ATTR_NAME, TGT0, l_chip_id));
FAPI_TRY(FAPI_ATTR_GET_PRIVILEGED(fapi2::ATTR_EC, TGT0, l_chip_ec));
fapi2::ATTR_CHIP_EC_FEATURE_HW403701_Type l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_EC_FEATURE_HW403701, TGT0, l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701));
fapi2::ATTR_CHIP_EC_FEATURE_HW414700_Type l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_CHIP_EC_FEATURE_HW414700, TGT0, l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700));
fapi2::ATTR_PROC_FABRIC_PUMP_MODE_Type l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_PROC_FABRIC_PUMP_MODE, TGT1, l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE));
fapi2::ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID_Type l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID, TGT1, l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID));
fapi2::ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID_Type l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID;
FAPI_TRY(FAPI_ATTR_GET(fapi2::ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID, TGT1, l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID));
fapi2::buffer<uint64_t> l_scom_buffer;
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011041ull, l_scom_buffer ));
constexpr auto l_NX_DMA_CH0_EFT_ENABLE_ON = 0x1;
l_scom_buffer.insert<63, 1, 63, uint64_t>(l_NX_DMA_CH0_EFT_ENABLE_ON );
constexpr auto l_NX_DMA_CH1_EFT_ENABLE_ON = 0x1;
l_scom_buffer.insert<62, 1, 63, uint64_t>(l_NX_DMA_CH1_EFT_ENABLE_ON );
constexpr auto l_NX_DMA_CH2_SYM_ENABLE_ON = 0x1;
l_scom_buffer.insert<58, 1, 63, uint64_t>(l_NX_DMA_CH2_SYM_ENABLE_ON );
constexpr auto l_NX_DMA_CH3_SYM_ENABLE_ON = 0x1;
l_scom_buffer.insert<57, 1, 63, uint64_t>(l_NX_DMA_CH3_SYM_ENABLE_ON );
constexpr auto l_NX_DMA_CH4_GZIP_ENABLE_ON = 0x1;
l_scom_buffer.insert<61, 1, 63, uint64_t>(l_NX_DMA_CH4_GZIP_ENABLE_ON );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011041ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011042ull, l_scom_buffer ));
constexpr auto l_NX_DMA_EFTCOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<33, 4, 60, uint64_t>(l_NX_DMA_EFTCOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_EFTDECOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<37, 4, 60, uint64_t>(l_NX_DMA_EFTDECOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_GZIPCOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<8, 4, 60, uint64_t>(l_NX_DMA_GZIPCOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_GZIPDECOMP_MAX_INRD_MAX_15_INRD = 0xf;
l_scom_buffer.insert<12, 4, 60, uint64_t>(l_NX_DMA_GZIPDECOMP_MAX_INRD_MAX_15_INRD );
constexpr auto l_NX_DMA_SYM_MAX_INRD_MAX_3_INRD = 0x3;
l_scom_buffer.insert<25, 4, 60, uint64_t>(l_NX_DMA_SYM_MAX_INRD_MAX_3_INRD );
if (((l_chip_id == 0x5) && (l_chip_ec == 0x10)) )
{
constexpr auto l_NX_DMA_SYM_CPB_CHECK_DISABLE_ON = 0x1;
l_scom_buffer.insert<48, 1, 63, uint64_t>(l_NX_DMA_SYM_CPB_CHECK_DISABLE_ON );
}
constexpr auto l_NX_DMA_EFT_COMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<23, 1, 63, uint64_t>(l_NX_DMA_EFT_COMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_EFT_DECOMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<24, 1, 63, uint64_t>(l_NX_DMA_EFT_DECOMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_GZIP_COMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<16, 1, 63, uint64_t>(l_NX_DMA_GZIP_COMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_GZIP_DECOMP_PREFETCH_ENABLE_ON = 0x1;
l_scom_buffer.insert<17, 1, 63, uint64_t>(l_NX_DMA_GZIP_DECOMP_PREFETCH_ENABLE_ON );
constexpr auto l_NX_DMA_EFT_SPBC_WRITE_ENABLE_OFF = 0x0;
l_scom_buffer.insert<56, 1, 63, uint64_t>(l_NX_DMA_EFT_SPBC_WRITE_ENABLE_OFF );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011042ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x201105cull, l_scom_buffer ));
constexpr auto l_NX_DMA_CH0_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<1, 4, 60, uint64_t>(l_NX_DMA_CH0_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH0_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<0, 1, 63, uint64_t>(l_NX_DMA_CH0_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH1_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<6, 4, 60, uint64_t>(l_NX_DMA_CH1_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH1_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<5, 1, 63, uint64_t>(l_NX_DMA_CH1_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH2_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<11, 4, 60, uint64_t>(l_NX_DMA_CH2_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH2_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<10, 1, 63, uint64_t>(l_NX_DMA_CH2_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH3_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<16, 4, 60, uint64_t>(l_NX_DMA_CH3_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH3_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<15, 1, 63, uint64_t>(l_NX_DMA_CH3_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_CH4_WATCHDOG_REF_DIV_DIVIDE_BY_512 = 0x9;
l_scom_buffer.insert<21, 4, 60, uint64_t>(l_NX_DMA_CH4_WATCHDOG_REF_DIV_DIVIDE_BY_512 );
constexpr auto l_NX_DMA_CH4_WATCHDOG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<20, 1, 63, uint64_t>(l_NX_DMA_CH4_WATCHDOG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_DMA_HANG_TIMER_ENBL_ON = 0x1;
l_scom_buffer.insert<25, 1, 63, uint64_t>(l_NX_DMA_DMA_HANG_TIMER_ENBL_ON );
constexpr auto l_NX_DMA_DMA_HANG_TIMER_REF_DIV_DIVIDE_BY_1024 = 0x8;
l_scom_buffer.insert<26, 4, 60, uint64_t>(l_NX_DMA_DMA_HANG_TIMER_REF_DIV_DIVIDE_BY_1024 );
FAPI_TRY(fapi2::putScom(TGT0, 0x201105cull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011083ull, l_scom_buffer ));
if (literal_1)
{
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<25, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<26, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<27, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<28, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<29, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<30, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 == literal_1))
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b1 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 != literal_1))
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 == literal_1))
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b1 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW403701 != literal_1))
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<3, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<40, 2, 62, uint64_t>(literal_0b11 );
}
if (literal_1)
{
l_scom_buffer.insert<42, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<43, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
}
FAPI_TRY(fapi2::putScom(TGT0, 0x2011083ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011086ull, l_scom_buffer ));
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<25, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<26, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<27, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<28, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<29, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<30, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<3, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<40, 2, 62, uint64_t>(literal_0b00 );
l_scom_buffer.insert<42, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<43, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011086ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011087ull, l_scom_buffer ));
if (literal_1)
{
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<25, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<26, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<27, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<28, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<29, 1, 63, uint64_t>(literal_0b0 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<2, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<30, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<3, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<40, 2, 62, uint64_t>(literal_0b00 );
}
if (literal_1)
{
l_scom_buffer.insert<42, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<43, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
}
FAPI_TRY(fapi2::putScom(TGT0, 0x2011087ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011095ull, l_scom_buffer ));
if ((l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE == fapi2::ENUM_ATTR_PROC_FABRIC_PUMP_MODE_CHIP_IS_GROUP))
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_ON = 0x1;
l_scom_buffer.insert<24, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_ON );
}
else if ((l_TGT1_ATTR_PROC_FABRIC_PUMP_MODE == fapi2::ENUM_ATTR_PROC_FABRIC_PUMP_MODE_CHIP_IS_NODE))
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_OFF = 0x0;
l_scom_buffer.insert<24, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_SKIP_G_OFF );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x21)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x22)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x23)) || ((l_chip_id == 0x6) && (l_chip_ec == 0x10))
|| ((l_chip_id == 0x6) && (l_chip_ec == 0x11)) || ((l_chip_id == 0x6) && (l_chip_ec == 0x12)) )
{
l_scom_buffer.insert<56, 4, 60, uint64_t>(l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_GROUP_ID );
l_scom_buffer.insert<60, 3, 61, uint64_t>(l_TGT1_ATTR_FABRIC_ADDR_EXTENSION_CHIP_ID );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<1, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<5, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<9, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_GROUP_ON = 0x1;
l_scom_buffer.insert<13, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_GROUP_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<2, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_WR_DISABLE_VG_NOT_SYS_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<6, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_DMA_RD_DISABLE_VG_NOT_SYS_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<10, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_WR_DISABLE_VG_NOT_SYS_ON );
}
if (((l_chip_id == 0x5) && (l_chip_ec == 0x20)) || ((l_chip_id == 0x5) && (l_chip_ec == 0x22)) || ((l_chip_id == 0x5)
&& (l_chip_ec == 0x23)) )
{
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_VG_NOT_SYS_ON = 0x1;
l_scom_buffer.insert<14, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_UMAC_RD_DISABLE_VG_NOT_SYS_ON );
}
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_RD_GO_M_QOS_ON = 0x1;
l_scom_buffer.insert<22, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_RD_GO_M_QOS_ON );
constexpr auto l_NX_PBI_CQ_WRAP_NXCQ_SCOM_ADDR_BAR_MODE_OFF = 0x0;
l_scom_buffer.insert<23, 1, 63, uint64_t>(l_NX_PBI_CQ_WRAP_NXCQ_SCOM_ADDR_BAR_MODE_OFF );
l_scom_buffer.insert<25, 2, 62, uint64_t>(literal_1 );
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0xFC );
l_scom_buffer.insert<48, 8, 56, uint64_t>(literal_0xFC );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011095ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110a8ull, l_scom_buffer ));
l_scom_buffer.insert<8, 4, 60, uint64_t>(literal_8 );
l_scom_buffer.insert<4, 4, 60, uint64_t>(literal_8 );
l_scom_buffer.insert<12, 4, 60, uint64_t>(literal_8 );
l_scom_buffer.insert<16, 4, 60, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110a8ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110c3ull, l_scom_buffer ));
l_scom_buffer.insert<27, 9, 55, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110c3ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110c4ull, l_scom_buffer ));
l_scom_buffer.insert<27, 9, 55, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110c4ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110c5ull, l_scom_buffer ));
l_scom_buffer.insert<27, 9, 55, uint64_t>(literal_8 );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110c5ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110d5ull, l_scom_buffer ));
constexpr auto l_NX_PBI_PBI_UMAC_CRB_READS_ENBL_ON = 0x1;
l_scom_buffer.insert<1, 1, 63, uint64_t>(l_NX_PBI_PBI_UMAC_CRB_READS_ENBL_ON );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110d5ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x20110d6ull, l_scom_buffer ));
l_scom_buffer.insert<9, 3, 61, uint64_t>(literal_2 );
constexpr auto l_NX_PBI_DISABLE_PROMOTE_ON = 0x1;
l_scom_buffer.insert<6, 1, 63, uint64_t>(l_NX_PBI_DISABLE_PROMOTE_ON );
FAPI_TRY(fapi2::putScom(TGT0, 0x20110d6ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011103ull, l_scom_buffer ));
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<25, 6, 58, uint64_t>(literal_0b111111 );
l_scom_buffer.insert<2, 2, 62, uint64_t>(literal_0b11 );
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0b11111111 );
l_scom_buffer.insert<48, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<49, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b1 );
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011103ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011106ull, l_scom_buffer ));
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<25, 6, 58, uint64_t>(literal_0b000000 );
l_scom_buffer.insert<2, 2, 62, uint64_t>(literal_0b00 );
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0b00000000 );
l_scom_buffer.insert<48, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<49, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b0 );
FAPI_TRY(fapi2::putScom(TGT0, 0x2011106ull, l_scom_buffer));
}
{
FAPI_TRY(fapi2::getScom( TGT0, 0x2011107ull, l_scom_buffer ));
if (literal_1)
{
l_scom_buffer.insert<0, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<10, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<11, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<12, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<13, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<14, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<15, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<16, 1, 63, uint64_t>(literal_0b0 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<17, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<18, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<19, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<1, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<20, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<21, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<22, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<23, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<24, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<25, 6, 58, uint64_t>(literal_0b000000 );
}
if (literal_1)
{
l_scom_buffer.insert<2, 2, 62, uint64_t>(literal_0b00 );
}
if (literal_1)
{
l_scom_buffer.insert<31, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<32, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<33, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<34, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<35, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<36, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<37, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<38, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<39, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<40, 8, 56, uint64_t>(literal_0b00000000 );
}
if (literal_1)
{
l_scom_buffer.insert<48, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<49, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<4, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<5, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<6, 1, 63, uint64_t>(literal_0b1 );
}
if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 != literal_0))
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b0 );
}
else if ((l_TGT0_ATTR_CHIP_EC_FEATURE_HW414700 == literal_0))
{
l_scom_buffer.insert<7, 1, 63, uint64_t>(literal_0b1 );
}
if (literal_1)
{
l_scom_buffer.insert<8, 1, 63, uint64_t>(literal_0b0 );
}
if (literal_1)
{
l_scom_buffer.insert<9, 1, 63, uint64_t>(literal_0b1 );
}
FAPI_TRY(fapi2::putScom(TGT0, 0x2011107ull, l_scom_buffer));
}
};
fapi_try_exit:
return fapi2::current_err;
}
|
#include "stdafx.h"
#include "EntryList.h"
#include "String.h"
EntryList::EntryList()
{
m_EntryCount = 0;
m_Pad = 0;
}
void EntryList::Parse()
{
m_EntryCount = m_Parser.Get<DWORD>();
m_Pad = m_Parser.Get<DWORD>();
if (m_EntryCount && m_EntryCount < _MaxEntriesLarge)
{
{
for (DWORD i = 0; i < m_EntryCount; i++)
{
EntryListEntryStruct entryListEntryStruct;
entryListEntryStruct.EntryLength = m_Parser.Get<DWORD>();
entryListEntryStruct.EntryLengthPad = m_Parser.Get<DWORD>();
m_Entry.push_back(entryListEntryStruct);
}
for (DWORD i = 0; i < m_EntryCount; i++)
{
size_t cbRemainingBytes = min(m_Entry[i].EntryLength, m_Parser.RemainingBytes());
m_Entry[i].EntryId.Init(cbRemainingBytes, m_Parser.GetCurrentAddress());
m_Parser.Advance(cbRemainingBytes);
}
}
}
}
_Check_return_ wstring EntryList::ToStringInternal()
{
auto szEntryList = formatmessage(IDS_ENTRYLISTDATA,
m_EntryCount,
m_Pad);
for (DWORD i = 0; i < m_EntryCount; i++)
{
szEntryList += formatmessage(IDS_ENTRYLISTENTRYID,
i,
m_Entry[i].EntryLength,
m_Entry[i].EntryLengthPad);
szEntryList += m_Entry[i].EntryId.ToString();
}
return szEntryList;
}
bad array count in EntryList::ToStringInternal
#include "stdafx.h"
#include "EntryList.h"
#include "String.h"
EntryList::EntryList()
{
m_EntryCount = 0;
m_Pad = 0;
}
void EntryList::Parse()
{
m_EntryCount = m_Parser.Get<DWORD>();
m_Pad = m_Parser.Get<DWORD>();
if (m_EntryCount && m_EntryCount < _MaxEntriesLarge)
{
{
for (DWORD i = 0; i < m_EntryCount; i++)
{
EntryListEntryStruct entryListEntryStruct;
entryListEntryStruct.EntryLength = m_Parser.Get<DWORD>();
entryListEntryStruct.EntryLengthPad = m_Parser.Get<DWORD>();
m_Entry.push_back(entryListEntryStruct);
}
for (DWORD i = 0; i < m_EntryCount; i++)
{
size_t cbRemainingBytes = min(m_Entry[i].EntryLength, m_Parser.RemainingBytes());
m_Entry[i].EntryId.Init(cbRemainingBytes, m_Parser.GetCurrentAddress());
m_Parser.Advance(cbRemainingBytes);
}
}
}
}
_Check_return_ wstring EntryList::ToStringInternal()
{
auto szEntryList = formatmessage(IDS_ENTRYLISTDATA,
m_EntryCount,
m_Pad);
for (DWORD i = 0; i < m_Entry.size(); i++)
{
szEntryList += formatmessage(IDS_ENTRYLISTENTRYID,
i,
m_Entry[i].EntryLength,
m_Entry[i].EntryLengthPad);
szEntryList += m_Entry[i].EntryId.ToString();
}
return szEntryList;
} |
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/perv/p9_sbe_lpc_init.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
//------------------------------------------------------------------------------
/// @file p9_sbe_lpc_init.H
///
/// @brief procedure to initialize LPC to enable communictation to PNOR
//------------------------------------------------------------------------------
// *HWP HW Owner : Abhishek Agarwal <abagarw8@in.ibm.com>
// *HWP HW Backup Owner : Srinivas V Naga <srinivan@in.ibm.com>
// *HWP FW Owner : sunil kumar <skumar8j@in.ibm.com>
// *HWP Team : Perv
// *HWP Level : 3
// *HWP Consumed by : SBE
//------------------------------------------------------------------------------
#ifndef _P9_SBE_LPC_INIT_H_
#define _P9_SBE_LPC_INIT_H_
#include <fapi2.H>
typedef fapi2::ReturnCode (*p9_sbe_lpc_init_FP_t)(const
fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>&);
/// @brief LPC init to enable connection to PNOR
///
/// @param[in] i_target_chip Reference to TARGET_TYPE_PROC_CHIP target
/// @return FAPI2_RC_SUCCESS if success, else error code.
extern "C"
{
const uint64_t LPC_LRESET_OE = 23;
const uint64_t LPC_LRESET_OUT = 22;
const uint32_t LPC_LRESET_DELAY_NS = 200000;
const uint64_t LPCM_OPB_MASTER_CONTROL_REG = 0xC0010008;
const uint32_t CPLT_CONF1_TC_LP_RESET = 12;
fapi2::ReturnCode p9_sbe_lpc_init(const
fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target_chip);
}
#endif
p9_sbe_lpc_init: Fix timeout setup
Factor LPC register access out into its own utility function, with
added timeout for the ADU access and proper FFDC if the ADU times out.
CQ: SW418354
Change-Id: I0bdfa355f00850cc93ad986365603384837310d7
Original-Change-Id: Ief05ccb022eeb1ec45d2f49f386fb58231966058
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/54637
Tested-by: FSP CI Jenkins <aa9e4d9ac7cd25905e9c0dd36d4150516e73dd86@us.ibm.com>
Reviewed-by: Joseph J. McGill <4a85c6614f9f065f63d8fd57cde15e48af07ea2a@us.ibm.com>
Tested-by: Jenkins Server <8e3f934e4c44875bc48d33da3ea13d93ba9a233f@us.ibm.com>
Tested-by: HWSV CI <ae069ce3805842f4ed79e0ef7868baadb5df0a6b@us.ibm.com>
Tested-by: Hostboot CI <52521565bd8ea18a2b112942dce4f4220a97c2c8@us.ibm.com>
Tested-by: PPE CI <dc75934ba5befb9221434e67a247b93aec46b36b@us.ibm.com>
Reviewed-by: Prachi Gupta <25a72946fc4ec2539bba3cff1fbb2916af6a7649@us.ibm.com>
Reviewed-by: Jennifer A. Stofer <ab93eca12e43608f33daa16a67357cd7b7e867ab@us.ibm.com>
/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/import/chips/p9/procedures/hwp/perv/p9_sbe_lpc_init.H $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2015,2019 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
//------------------------------------------------------------------------------
/// @file p9_sbe_lpc_init.H
///
/// @brief procedure to initialize LPC to enable communictation to PNOR
//------------------------------------------------------------------------------
// *HWP HW Owner : Abhishek Agarwal <abagarw8@in.ibm.com>
// *HWP HW Backup Owner : Srinivas V Naga <srinivan@in.ibm.com>
// *HWP FW Owner : sunil kumar <skumar8j@in.ibm.com>
// *HWP Team : Perv
// *HWP Level : 3
// *HWP Consumed by : SBE
//------------------------------------------------------------------------------
#ifndef _P9_SBE_LPC_INIT_H_
#define _P9_SBE_LPC_INIT_H_
#include <fapi2.H>
typedef fapi2::ReturnCode (*p9_sbe_lpc_init_FP_t)(const
fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>&);
/// @brief LPC init to enable connection to PNOR
///
/// @param[in] i_target_chip Reference to TARGET_TYPE_PROC_CHIP target
/// @return FAPI2_RC_SUCCESS if success, else error code.
extern "C"
{
const uint64_t LPC_LRESET_OE = 23;
const uint64_t LPC_LRESET_OUT = 22;
const uint32_t LPC_LRESET_DELAY_NS = 200000;
const uint32_t LPCM_OPB_MASTER_CONTROL_REG = 0xC0010008;
const uint32_t LPCM_OPB_MASTER_CONTROL_REG_TIMEOUT_ENABLE = 2;
const uint32_t LPCM_OPB_MASTER_TIMEOUT_REG = 0xC0010040;
const uint32_t LPCM_OPB_MASTER_TIMEOUT_VALUE = 0x01312D00; // 50ms at 1600MHz Nest / 400MHz OPB
const uint32_t LPCM_LPC_MASTER_TIMEOUT_REG = 0xC001202C;
const uint32_t LPCM_LPC_MASTER_TIMEOUT_VALUE = 0xFE000000;
const uint32_t CPLT_CONF1_TC_LP_RESET = 12;
fapi2::ReturnCode p9_sbe_lpc_init(const
fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target_chip);
}
#endif
|
#include <eosio/chain_api_plugin/chain_api_plugin.hpp>
#include <eosio/chain/exceptions.hpp>
#include <fc/io/json.hpp>
namespace eosio {
static appbase::abstract_plugin& _chain_api_plugin = app().register_plugin<chain_api_plugin>();
using namespace eosio;
class chain_api_plugin_impl {
public:
chain_api_plugin_impl(controller& db)
: db(db) {}
controller& db;
};
chain_api_plugin::chain_api_plugin(){}
chain_api_plugin::~chain_api_plugin(){}
void chain_api_plugin::set_program_options(options_description&, options_description&) {}
void chain_api_plugin::plugin_initialize(const variables_map&) {}
struct async_result_visitor : public fc::visitor<fc::variant> {
template<typename T>
fc::variant operator()(const T& v) const {
return fc::variant(v);
}
};
namespace {
template<typename T>
T parse_params(const std::string& body) {
if (body.empty()) {
EOS_THROW(chain::invalid_http_request, "A Request body is required");
}
try {
try {
return fc::json::from_string(body).as<T>();
} catch (const chain::chain_exception& e) { // EOS_RETHROW_EXCEPTIONS does not re-type these so, re-code it
throw fc::exception(e);
}
} EOS_RETHROW_EXCEPTIONS(chain::invalid_http_request, "Unable to parse valid input from POST body");
}
}
#define CALL_WITH_400(api_name, api_handle, api_namespace, call_name, http_response_code, params_type) \
{std::string("/v1/" #api_name "/" #call_name), \
[api_handle](string, string body, url_response_callback cb) mutable { \
api_handle.validate(); \
try { \
auto params = parse_params<api_namespace::call_name ## _params, params_type>(body);\
fc::variant result( api_handle.call_name( std::move(params) ) ); \
cb(http_response_code, std::move(result)); \
} catch (...) { \
http_plugin::handle_exception(#api_name, #call_name, body, cb); \
} \
}}
#define CALL_ASYNC_WITH_400(api_name, api_handle, api_namespace, call_name, call_result, http_response_code, params_type) \
{std::string("/v1/" #api_name "/" #call_name), \
[api_handle](string, string body, url_response_callback cb) mutable { \
api_handle.validate(); \
try { \
auto params = parse_params<api_namespace::call_name ## _params, params_type>(body);\
api_handle.call_name( std::move(params),\
[cb, body](const fc::static_variant<fc::exception_ptr, call_result>& result){\
if (result.contains<fc::exception_ptr>()) {\
try {\
result.get<fc::exception_ptr>()->dynamic_rethrow_exception();\
} catch (...) {\
http_plugin::handle_exception(#api_name, #call_name, body, cb);\
}\
} else {\
cb(http_response_code, result.visit(async_result_visitor()));\
}\
});\
} catch (...) { \
http_plugin::handle_exception(#api_name, #call_name, body, cb); \
} \
}\
}
#define CHAIN_RO_CALL(call_name, http_response_code, params_type) CALL_WITH_400(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
#define CHAIN_RW_CALL(call_name, http_response_code, params_type) CALL_WITH_400(chain, rw_api, chain_apis::read_write, call_name, http_response_code, params_type)
#define CHAIN_RO_CALL_ASYNC(call_name, call_result, http_response_code, params_type) CALL_ASYNC_WITH_400(chain, ro_api, chain_apis::read_only, call_name, call_result, http_response_code, params_type)
#define CHAIN_RW_CALL_ASYNC(call_name, call_result, http_response_code, params_type) CALL_ASYNC_WITH_400(chain, rw_api, chain_apis::read_write, call_name, call_result, http_response_code, params_type)
#define CHAIN_RO_CALL_WITH_400(call_name, http_response_code) CALL_WITH_400(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
void chain_api_plugin::plugin_startup() {
ilog( "starting chain_api_plugin" );
my.reset(new chain_api_plugin_impl(app().get_plugin<chain_plugin>().chain()));
auto& chain = app().get_plugin<chain_plugin>();
auto ro_api = chain.get_read_only_api();
auto rw_api = chain.get_read_write_api();
auto& _http_plugin = app().get_plugin<http_plugin>();
ro_api.set_shorten_abi_errors( !_http_plugin.verbose_errors() );
_http_plugin.add_api({
CHAIN_RO_CALL(get_info, 200, http_params_types::no_params_required)}, appbase::priority::medium_high);
_http_plugin.add_api({
CHAIN_RO_CALL(get_activated_protocol_features, 200, http_params_types::possible_no_params),
CHAIN_RO_CALL(get_block, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_block_info, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_block_header_state, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_account, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_code, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_code_hash, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_abi, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_raw_code_and_abi, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_raw_abi, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_table_rows, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_table_by_scope, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_currency_balance, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_currency_stats, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_producers, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_producer_schedule, 200, http_params_types::no_params_required),
CHAIN_RO_CALL(get_scheduled_transactions, 200, http_params_types::params_required),
CHAIN_RO_CALL(abi_json_to_bin, 200, http_params_types::params_required),
CHAIN_RO_CALL(abi_bin_to_json, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_required_keys, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_transaction_id, 200, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(push_block, chain_apis::read_write::push_block_results, 202, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(push_transaction, chain_apis::read_write::push_transaction_results, 202, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(push_transactions, chain_apis::read_write::push_transactions_results, 202, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(send_transaction, chain_apis::read_write::send_transaction_results, 202, http_params_types::params_required)
});
if (chain.account_queries_enabled()) {
_http_plugin.add_async_api({
CHAIN_RO_CALL_WITH_400(get_accounts_by_authorizers, 200),
});
}
}
void chain_api_plugin::plugin_shutdown() {}
}
Update chain_api_plugin.cpp
#include <eosio/chain_api_plugin/chain_api_plugin.hpp>
#include <eosio/chain/exceptions.hpp>
#include <fc/io/json.hpp>
namespace eosio {
static appbase::abstract_plugin& _chain_api_plugin = app().register_plugin<chain_api_plugin>();
using namespace eosio;
class chain_api_plugin_impl {
public:
chain_api_plugin_impl(controller& db)
: db(db) {}
controller& db;
};
chain_api_plugin::chain_api_plugin(){}
chain_api_plugin::~chain_api_plugin(){}
void chain_api_plugin::set_program_options(options_description&, options_description&) {}
void chain_api_plugin::plugin_initialize(const variables_map&) {}
struct async_result_visitor : public fc::visitor<fc::variant> {
template<typename T>
fc::variant operator()(const T& v) const {
return fc::variant(v);
}
};
namespace {
template<typename T>
T parse_params(const std::string& body) {
if (body.empty()) {
EOS_THROW(chain::invalid_http_request, "A Request body is required");
}
try {
try {
return fc::json::from_string(body).as<T>();
} catch (const chain::chain_exception& e) { // EOS_RETHROW_EXCEPTIONS does not re-type these so, re-code it
throw fc::exception(e);
}
} EOS_RETHROW_EXCEPTIONS(chain::invalid_http_request, "Unable to parse valid input from POST body");
}
}
#define CALL_WITH_400(api_name, api_handle, api_namespace, call_name, http_response_code, params_type) \
{std::string("/v1/" #api_name "/" #call_name), \
[api_handle](string, string body, url_response_callback cb) mutable { \
api_handle.validate(); \
try { \
auto params = parse_params<api_namespace::call_name ## _params, params_type>(body);\
fc::variant result( api_handle.call_name( std::move(params) ) ); \
cb(http_response_code, std::move(result)); \
} catch (...) { \
http_plugin::handle_exception(#api_name, #call_name, body, cb); \
} \
}}
#define CALL_ASYNC_WITH_400(api_name, api_handle, api_namespace, call_name, call_result, http_response_code, params_type) \
{std::string("/v1/" #api_name "/" #call_name), \
[api_handle](string, string body, url_response_callback cb) mutable { \
api_handle.validate(); \
try { \
auto params = parse_params<api_namespace::call_name ## _params, params_type>(body);\
api_handle.call_name( std::move(params),\
[cb, body](const fc::static_variant<fc::exception_ptr, call_result>& result){\
if (result.contains<fc::exception_ptr>()) {\
try {\
result.get<fc::exception_ptr>()->dynamic_rethrow_exception();\
} catch (...) {\
http_plugin::handle_exception(#api_name, #call_name, body, cb);\
}\
} else {\
cb(http_response_code, result.visit(async_result_visitor()));\
}\
});\
} catch (...) { \
http_plugin::handle_exception(#api_name, #call_name, body, cb); \
} \
}\
}
#define CHAIN_RO_CALL(call_name, http_response_code, params_type) CALL_WITH_400(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
#define CHAIN_RW_CALL(call_name, http_response_code, params_type) CALL_WITH_400(chain, rw_api, chain_apis::read_write, call_name, http_response_code, params_type)
#define CHAIN_RO_CALL_ASYNC(call_name, call_result, http_response_code, params_type) CALL_ASYNC_WITH_400(chain, ro_api, chain_apis::read_only, call_name, call_result, http_response_code, params_type)
#define CHAIN_RW_CALL_ASYNC(call_name, call_result, http_response_code, params_type) CALL_ASYNC_WITH_400(chain, rw_api, chain_apis::read_write, call_name, call_result, http_response_code, params_type)
#define CHAIN_RO_CALL_WITH_400(call_name, http_response_code, params_type) CALL_WITH_400(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
void chain_api_plugin::plugin_startup() {
ilog( "starting chain_api_plugin" );
my.reset(new chain_api_plugin_impl(app().get_plugin<chain_plugin>().chain()));
auto& chain = app().get_plugin<chain_plugin>();
auto ro_api = chain.get_read_only_api();
auto rw_api = chain.get_read_write_api();
auto& _http_plugin = app().get_plugin<http_plugin>();
ro_api.set_shorten_abi_errors( !_http_plugin.verbose_errors() );
_http_plugin.add_api({
CHAIN_RO_CALL(get_info, 200, http_params_types::no_params_required)}, appbase::priority::medium_high);
_http_plugin.add_api({
CHAIN_RO_CALL(get_activated_protocol_features, 200, http_params_types::possible_no_params),
CHAIN_RO_CALL(get_block, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_block_info, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_block_header_state, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_account, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_code, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_code_hash, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_abi, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_raw_code_and_abi, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_raw_abi, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_table_rows, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_table_by_scope, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_currency_balance, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_currency_stats, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_producers, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_producer_schedule, 200, http_params_types::no_params_required),
CHAIN_RO_CALL(get_scheduled_transactions, 200, http_params_types::params_required),
CHAIN_RO_CALL(abi_json_to_bin, 200, http_params_types::params_required),
CHAIN_RO_CALL(abi_bin_to_json, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_required_keys, 200, http_params_types::params_required),
CHAIN_RO_CALL(get_transaction_id, 200, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(push_block, chain_apis::read_write::push_block_results, 202, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(push_transaction, chain_apis::read_write::push_transaction_results, 202, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(push_transactions, chain_apis::read_write::push_transactions_results, 202, http_params_types::params_required),
CHAIN_RW_CALL_ASYNC(send_transaction, chain_apis::read_write::send_transaction_results, 202, http_params_types::params_required)
});
if (chain.account_queries_enabled()) {
_http_plugin.add_async_api({
CHAIN_RO_CALL_WITH_400(get_accounts_by_authorizers, 200),
});
}
}
void chain_api_plugin::plugin_shutdown() {}
}
|
/*
Copyright (C) 2003 by Jorrit Tyberghein
(C) 2003 by Frank Richter
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "cssysdef.h"
#include "csutil/util.h"
#include "iutil/document.h"
#include "iutil/objreg.h"
#include "iengine/engine.h"
#include "iengine/renderloop.h"
#include "imap/services.h"
#include "ivaria/reporter.h"
#include "iengine/rendersteps/irenderstep.h"
#include "iengine/rendersteps/icontainer.h"
#include "rlloader.h"
CS_LEAKGUARD_IMPLEMENT (csRenderLoopLoader);
// Plugin stuff
SCF_IMPLEMENT_IBASE(csRenderLoopLoader);
SCF_IMPLEMENTS_INTERFACE(iLoaderPlugin);
SCF_IMPLEMENTS_INTERFACE(iComponent);
SCF_IMPLEMENT_IBASE_END
CS_IMPLEMENT_PLUGIN
SCF_IMPLEMENT_FACTORY(csRenderLoopLoader)
//---------------------------------------------------------------------------
csRenderLoopLoader::csRenderLoopLoader (iBase *p)
{
SCF_CONSTRUCT_IBASE (p);
InitTokenTable (tokens);
}
csRenderLoopLoader::~csRenderLoopLoader ()
{
SCF_DESTRUCT_IBASE();
}
bool csRenderLoopLoader::Initialize(iObjectRegistry *object_reg)
{
csRenderLoopLoader::object_reg = object_reg;
synldr = CS_QUERY_REGISTRY (object_reg, iSyntaxService);
rsp.Initialize (object_reg);
return true;
}
bool csRenderLoopLoader::ParseRenderSteps (iRenderLoop* loop,
iDocumentNode* node)
{
csRef<iRenderStepContainer> cont =
scfQueryInterface<iRenderStepContainer> (loop);
if (!cont)
{
if (synldr)
synldr->ReportError (
"crystalspace.renderloop.load",
node, "Internal error: doesn't implement iRenderStepContainer!");
return false;
}
return rsp.ParseRenderSteps (cont, node);
}
csPtr<iBase> csRenderLoopLoader::Parse (iDocumentNode* node,
iStreamSource*, iLoaderContext* ldr_context, iBase* /*context*/)
{
csRef<iEngine> engine = CS_QUERY_REGISTRY (object_reg, iEngine);
if (!engine)
{
if (synldr)
synldr->ReportError (
"crystalspace.renderloop.load",
node, "Can't find engine!");
return 0;
}
iRenderLoopManager* loopmgr = engine->GetRenderLoopManager ();
if (!loopmgr)
{
if (synldr)
synldr->ReportError (
"crystalspace.renderloop.load",
node, "Engine doesn't have a render loop manager!");
return 0;
}
csRef<iRenderLoop> loop = loopmgr->Create ();
csRef<iObject> obj = scfQueryInterface<iObject> (loop);
if (ldr_context->GetRegion ())
ldr_context->GetRegion ()->QueryObject ()->ObjAdd (obj);
char* loopName = 0;
if (node)
{
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
csStringID id = tokens.Request (child->GetValue ());
switch (id)
{
case XMLTOKEN_NAME:
{
loopName = csStrNew (child->GetContentsValue ());
}
break;
case XMLTOKEN_STEPS:
{
if (!ParseRenderSteps (loop, child))
{
goto error;
}
}
break;
default:
if (synldr) synldr->ReportBadToken (child);
goto error;
}
}
}
if (loopName)
{
if (!loopmgr->Register (loopName, loop))
{
if (synldr)
{
synldr->Report (
"crystalspace.renderloop.loop.loader",
CS_REPORTER_SEVERITY_WARNING,
node,
"Couldn't register render loop '%s'. Maybe a loop of the same "
"name already exists?",
loopName);
}
}
}
else
{
if (synldr)
{
synldr->Report (
"crystalspace.renderloop.loop.loader",
CS_REPORTER_SEVERITY_WARNING,
node,
"Render loop has no name and is therefore inaccessible. "
"This may not be what you want.");
}
}
if (loop->GetStepCount () == 0)
{
if (synldr)
{
synldr->Report (
"crystalspace.renderloop.loop.loader",
CS_REPORTER_SEVERITY_WARNING,
node,
"Render loop has no steps. "
"This may not be what you want.");
}
}
delete[] loopName;
return csPtr<iBase> (loop);
error:
delete[] loopName;
return 0;
}
Fixed compile errors.
git-svn-id: 28d9401aa571d5108e51b194aae6f24ca5964c06@23336 8cc4aa7f-3514-0410-904f-f2cc9021211c
/*
Copyright (C) 2003 by Jorrit Tyberghein
(C) 2003 by Frank Richter
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "cssysdef.h"
#include "csutil/util.h"
#include "iutil/document.h"
#include "iutil/objreg.h"
#include "iutil/object.h"
#include "iengine/engine.h"
#include "iengine/renderloop.h"
#include "imap/services.h"
#include "imap/ldrctxt.h"
#include "iengine/region.h"
#include "ivaria/reporter.h"
#include "iengine/rendersteps/irenderstep.h"
#include "iengine/rendersteps/icontainer.h"
#include "rlloader.h"
CS_LEAKGUARD_IMPLEMENT (csRenderLoopLoader);
// Plugin stuff
SCF_IMPLEMENT_IBASE(csRenderLoopLoader);
SCF_IMPLEMENTS_INTERFACE(iLoaderPlugin);
SCF_IMPLEMENTS_INTERFACE(iComponent);
SCF_IMPLEMENT_IBASE_END
CS_IMPLEMENT_PLUGIN
SCF_IMPLEMENT_FACTORY(csRenderLoopLoader)
//---------------------------------------------------------------------------
csRenderLoopLoader::csRenderLoopLoader (iBase *p)
{
SCF_CONSTRUCT_IBASE (p);
InitTokenTable (tokens);
}
csRenderLoopLoader::~csRenderLoopLoader ()
{
SCF_DESTRUCT_IBASE();
}
bool csRenderLoopLoader::Initialize(iObjectRegistry *object_reg)
{
csRenderLoopLoader::object_reg = object_reg;
synldr = CS_QUERY_REGISTRY (object_reg, iSyntaxService);
rsp.Initialize (object_reg);
return true;
}
bool csRenderLoopLoader::ParseRenderSteps (iRenderLoop* loop,
iDocumentNode* node)
{
csRef<iRenderStepContainer> cont =
scfQueryInterface<iRenderStepContainer> (loop);
if (!cont)
{
if (synldr)
synldr->ReportError (
"crystalspace.renderloop.load",
node, "Internal error: doesn't implement iRenderStepContainer!");
return false;
}
return rsp.ParseRenderSteps (cont, node);
}
csPtr<iBase> csRenderLoopLoader::Parse (iDocumentNode* node,
iStreamSource*, iLoaderContext* ldr_context, iBase* /*context*/)
{
csRef<iEngine> engine = CS_QUERY_REGISTRY (object_reg, iEngine);
if (!engine)
{
if (synldr)
synldr->ReportError (
"crystalspace.renderloop.load",
node, "Can't find engine!");
return 0;
}
iRenderLoopManager* loopmgr = engine->GetRenderLoopManager ();
if (!loopmgr)
{
if (synldr)
synldr->ReportError (
"crystalspace.renderloop.load",
node, "Engine doesn't have a render loop manager!");
return 0;
}
csRef<iRenderLoop> loop = loopmgr->Create ();
csRef<iObject> obj = scfQueryInterface<iObject> (loop);
if (ldr_context->GetRegion ())
ldr_context->GetRegion ()->QueryObject ()->ObjAdd (obj);
char* loopName = 0;
if (node)
{
csRef<iDocumentNodeIterator> it = node->GetNodes ();
while (it->HasNext ())
{
csRef<iDocumentNode> child = it->Next ();
if (child->GetType () != CS_NODE_ELEMENT) continue;
csStringID id = tokens.Request (child->GetValue ());
switch (id)
{
case XMLTOKEN_NAME:
{
loopName = csStrNew (child->GetContentsValue ());
}
break;
case XMLTOKEN_STEPS:
{
if (!ParseRenderSteps (loop, child))
{
goto error;
}
}
break;
default:
if (synldr) synldr->ReportBadToken (child);
goto error;
}
}
}
if (loopName)
{
if (!loopmgr->Register (loopName, loop))
{
if (synldr)
{
synldr->Report (
"crystalspace.renderloop.loop.loader",
CS_REPORTER_SEVERITY_WARNING,
node,
"Couldn't register render loop '%s'. Maybe a loop of the same "
"name already exists?",
loopName);
}
}
}
else
{
if (synldr)
{
synldr->Report (
"crystalspace.renderloop.loop.loader",
CS_REPORTER_SEVERITY_WARNING,
node,
"Render loop has no name and is therefore inaccessible. "
"This may not be what you want.");
}
}
if (loop->GetStepCount () == 0)
{
if (synldr)
{
synldr->Report (
"crystalspace.renderloop.loop.loader",
CS_REPORTER_SEVERITY_WARNING,
node,
"Render loop has no steps. "
"This may not be what you want.");
}
}
delete[] loopName;
return csPtr<iBase> (loop);
error:
delete[] loopName;
return 0;
}
|
/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
#include "Comb.h"
#include <algorithm>
#include <functional> // function
#include <unordered_set>
#include "../utils/polygonUtils.h"
#include "../utils/PolygonsPointIndex.h"
#include "../sliceDataStorage.h"
#include "../utils/SVG.h"
namespace cura {
LocToLineGrid& Comb::getOutsideLocToLine()
{
return *outside_loc_to_line;
}
Polygons& Comb::getBoundaryOutside()
{
return *boundary_outside;
}
Comb::Comb(SliceDataStorage& storage, int layer_nr, Polygons& comb_boundary_inside, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance)
: storage(storage)
, layer_nr(layer_nr)
, offset_from_outlines(comb_boundary_offset) // between second wall and infill / other walls
, max_moveInside_distance2(offset_from_outlines * 2 * offset_from_outlines * 2)
, offset_from_outlines_outside(travel_avoid_distance)
, offset_from_inside_to_outside(offset_from_outlines + offset_from_outlines_outside)
, max_crossing_dist2(offset_from_inside_to_outside * offset_from_inside_to_outside * 2) // so max_crossing_dist = offset_from_inside_to_outside * sqrt(2) =approx 1.5 to allow for slightly diagonal crossings and slightly inaccurate crossing computation
, avoid_other_parts(travel_avoid_other_parts)
, boundary_inside( comb_boundary_inside )
, partsView_inside( boundary_inside.splitIntoPartsView() ) // WARNING !! changes the order of boundary_inside !!
, inside_loc_to_line(PolygonUtils::createLocToLineGrid(boundary_inside, comb_boundary_offset))
, boundary_outside(
[&storage, layer_nr, travel_avoid_distance]()
{
return storage.getLayerOutlines(layer_nr, false).unionPolygons().offset(travel_avoid_distance);
}
)
, outside_loc_to_line(
[](Comb* comber, const int64_t offset_from_inside_to_outside)
{
return PolygonUtils::createLocToLineGrid(comber->getBoundaryOutside(), offset_from_inside_to_outside * 3 / 2);
}
, this
, offset_from_inside_to_outside
)
{
}
Comb::~Comb()
{
if (inside_loc_to_line)
{
delete inside_loc_to_line;
}
}
bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _startInside, bool _endInside, int64_t max_comb_distance_ignored, bool via_outside_makes_combing_fail, bool fail_on_unavoidable_obstacles)
{
if (shorterThen(endPoint - startPoint, max_comb_distance_ignored))
{
return true;
}
//Move start and end point inside the comb boundary
unsigned int start_inside_poly = NO_INDEX;
const bool startInside = moveInside(_startInside, startPoint, start_inside_poly);
unsigned int end_inside_poly = NO_INDEX;
const bool endInside = moveInside(_endInside, endPoint, end_inside_poly);
unsigned int start_part_boundary_poly_idx;
unsigned int end_part_boundary_poly_idx;
unsigned int start_part_idx = (start_inside_poly == NO_INDEX)? NO_INDEX : partsView_inside.getPartContaining(start_inside_poly, &start_part_boundary_poly_idx);
unsigned int end_part_idx = (end_inside_poly == NO_INDEX)? NO_INDEX : partsView_inside.getPartContaining(end_inside_poly, &end_part_boundary_poly_idx);
if (startInside && endInside && start_part_idx == end_part_idx)
{ // normal combing within part
PolygonsPart part = partsView_inside.assemblePart(start_part_idx);
combPaths.emplace_back();
return LinePolygonsCrossings::comb(part, *inside_loc_to_line, startPoint, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
}
else
{ // comb inside part to edge (if needed) >> move through air avoiding other parts >> comb inside end part upto the endpoint (if needed)
// INSIDE | in_between | OUTSIDE | in_between | INSIDE
// ^crossing_1_in ^crossing_1_mid ^crossing_1_out ^crossing_2_out ^crossing_2_mid ^crossing_2_in
//
// when startPoint is inside crossing_1_in is of interest
// when it is in between inside and outside it is equal to crossing_1_mid
if (via_outside_makes_combing_fail)
{
return false;
}
Crossing start_crossing(startPoint, startInside, start_part_idx, start_part_boundary_poly_idx, boundary_inside, inside_loc_to_line);
Crossing end_crossing(endPoint, endInside, end_part_idx, end_part_boundary_poly_idx, boundary_inside, inside_loc_to_line);
{ // find crossing over the in-between area between inside and outside
start_crossing.findCrossingInOrMid(partsView_inside, endPoint);
end_crossing.findCrossingInOrMid(partsView_inside, start_crossing.in_or_mid);
}
bool skip_avoid_other_parts_path = false;
if (skip_avoid_other_parts_path && vSize2(start_crossing.in_or_mid - end_crossing.in_or_mid) < offset_from_inside_to_outside * offset_from_inside_to_outside * 4)
{ // parts are next to eachother, i.e. the direct crossing will always be smaller than two crossings via outside
skip_avoid_other_parts_path = true;
}
if (avoid_other_parts && !skip_avoid_other_parts_path)
{ // compute the crossing points when moving through air
// comb through all air, since generally the outside consists of a single part
bool success = start_crossing.findOutside(*boundary_outside, end_crossing.in_or_mid, fail_on_unavoidable_obstacles, *this);
if (!success)
{
return false;
}
success = end_crossing.findOutside(*boundary_outside, start_crossing.out, fail_on_unavoidable_obstacles, *this);
if (!success)
{
return false;
}
}
// generate the actual comb paths
if (startInside)
{
// start to boundary
assert(start_crossing.dest_part.size() > 0 && "The part we start inside when combing should have been computed already!");
combPaths.emplace_back();
bool combing_succeeded = LinePolygonsCrossings::comb(start_crossing.dest_part, *inside_loc_to_line, startPoint, start_crossing.in_or_mid, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
if (!combing_succeeded)
{ // Couldn't comb between start point and computed crossing from the start part! Happens for very thin parts when the offset_to_get_off_boundary moves points to outside the polygon
return false;
}
}
// throught air from boundary to boundary
if (avoid_other_parts && !skip_avoid_other_parts_path)
{
combPaths.emplace_back();
combPaths.throughAir = true;
if ( vSize(start_crossing.in_or_mid - end_crossing.in_or_mid) < vSize(start_crossing.in_or_mid - start_crossing.out) + vSize(end_crossing.in_or_mid - end_crossing.out) )
{ // via outside is moving more over the in-between zone
combPaths.back().push_back(start_crossing.in_or_mid);
combPaths.back().push_back(end_crossing.in_or_mid);
}
else
{
bool combing_succeeded = LinePolygonsCrossings::comb(*boundary_outside, *outside_loc_to_line, start_crossing.out, end_crossing.out, combPaths.back(), offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
if (!combing_succeeded)
{
return false;
}
}
}
else
{ // directly through air (not avoiding other parts)
combPaths.emplace_back();
combPaths.throughAir = true;
combPaths.back().cross_boundary = true; // note: we don't actually know whether this is cross boundary, but it might very well be
combPaths.back().push_back(start_crossing.in_or_mid);
combPaths.back().push_back(end_crossing.in_or_mid);
}
if (skip_avoid_other_parts_path)
{
if (startInside == endInside && start_part_idx == end_part_idx)
{
if (startInside)
{ // both start and end are inside
combPaths.back().cross_boundary = PolygonUtils::polygonCollidesWithLineSegment(startPoint, endPoint, *inside_loc_to_line);
}
else
{ // both start and end are outside
combPaths.back().cross_boundary = PolygonUtils::polygonCollidesWithLineSegment(startPoint, endPoint, *outside_loc_to_line);
}
}
else
{
combPaths.back().cross_boundary = true;
}
}
if (endInside)
{
// boundary to end
assert(end_crossing.dest_part.size() > 0 && "The part we end up inside when combing should have been computed already!");
combPaths.emplace_back();
bool combing_succeeded = LinePolygonsCrossings::comb(end_crossing.dest_part, *inside_loc_to_line, end_crossing.in_or_mid, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
if (!combing_succeeded)
{ // Couldn't comb between end point and computed crossing to the end part! Happens for very thin parts when the offset_to_get_off_boundary moves points to outside the polygon
return false;
}
}
return true;
}
}
Comb::Crossing::Crossing(const Point& dest_point, const bool dest_is_inside, const unsigned int dest_part_idx, const unsigned int dest_part_boundary_crossing_poly_idx, const Polygons& boundary_inside, const LocToLineGrid* inside_loc_to_line)
: dest_is_inside(dest_is_inside)
, boundary_inside(boundary_inside)
, inside_loc_to_line(inside_loc_to_line)
, dest_point(dest_point)
, dest_part_idx(dest_part_idx)
{
if (dest_is_inside)
{
dest_crossing_poly = boundary_inside[dest_part_boundary_crossing_poly_idx]; // initialize with most obvious poly, cause mostly a combing move will move outside the part, rather than inside a hole in the part
}
}
bool Comb::moveInside(bool is_inside, Point& dest_point, unsigned int& inside_poly)
{
if (is_inside)
{
ClosestPolygonPoint cpp = PolygonUtils::ensureInsideOrOutside(boundary_inside, dest_point, offset_extra_start_end, max_moveInside_distance2, &boundary_inside, inside_loc_to_line);
if (!cpp.isValid())
{
return false;
}
else
{
inside_poly = cpp.poly_idx;
return true;
}
}
return false;
}
void Comb::Crossing::findCrossingInOrMid(const PartsView& partsView_inside, const Point close_to)
{
if (dest_is_inside)
{ // in-case
// find the point on the start inside-polygon closest to the endpoint, but also kind of close to the start point
Point _dest_point(dest_point); // copy to local variable for lambda capture
std::function<int(Point)> close_towards_start_penalty_function([_dest_point](Point candidate){ return vSize2((candidate - _dest_point) / 10); });
dest_part = partsView_inside.assemblePart(dest_part_idx);
ClosestPolygonPoint boundary_crossing_point;
{ // set [result] to a point on the destination part closest to close_to (but also a bit close to _dest_point)
std::unordered_set<unsigned int> dest_part_poly_indices;
for (unsigned int poly_idx : partsView_inside[dest_part_idx])
{
dest_part_poly_indices.emplace(poly_idx);
}
coord_t dist2_score = std::numeric_limits<coord_t>::max();
std::function<bool (const PolygonsPointIndex&)> line_processor
= [close_to, _dest_point, &boundary_crossing_point, &dist2_score, &dest_part_poly_indices](const PolygonsPointIndex& boundary_segment)
{
if (dest_part_poly_indices.find(boundary_segment.poly_idx) == dest_part_poly_indices.end())
{ // we're not looking at a polygon from the dest_part
return true; // a.k.a. continue;
}
Point closest_here = LinearAlg2D::getClosestOnLineSegment(close_to, boundary_segment.p(), boundary_segment.next().p());
coord_t dist2_score_here = vSize2(close_to - closest_here) + vSize2(_dest_point - closest_here) / 10;
if (dist2_score_here < dist2_score)
{
dist2_score = dist2_score_here;
boundary_crossing_point = ClosestPolygonPoint(closest_here, boundary_segment.point_idx, boundary_segment.getPolygon(), boundary_segment.poly_idx);
}
return true;
};
inside_loc_to_line->processLine(std::make_pair(dest_point, close_to), line_processor);
}
Point result(boundary_crossing_point.p()); // the inside point of the crossing
if (!boundary_crossing_point.isValid())
{ // no point has been found in the sparse grid
result = dest_point;
}
int64_t max_dist2 = std::numeric_limits<int64_t>::max();
ClosestPolygonPoint crossing_1_in_cp = PolygonUtils::ensureInsideOrOutside(dest_part, result, boundary_crossing_point, offset_dist_to_get_from_on_the_polygon_to_outside, max_dist2, &boundary_inside, inside_loc_to_line, close_towards_start_penalty_function);
if (crossing_1_in_cp.isValid())
{
dest_crossing_poly = crossing_1_in_cp.poly;
in_or_mid = result;
}
else
{ // part is too small to be ensuring a point inside with the given distance
in_or_mid = dest_point; // just use the startPoint or endPoint itself
}
}
else
{
in_or_mid = dest_point; // mid-case
}
};
bool Comb::Crossing::findOutside(const Polygons& outside, const Point close_to, const bool fail_on_unavoidable_obstacles, Comb& comber)
{
out = in_or_mid;
if (dest_is_inside || outside.inside(in_or_mid, true)) // start in_between
{ // move outside
Point preferred_crossing_1_out = in_or_mid + normal(close_to - in_or_mid, comber.offset_from_inside_to_outside);
std::function<int(Point)> close_to_penalty_function([preferred_crossing_1_out](Point candidate){ return vSize2((candidate - preferred_crossing_1_out) / 2); });
std::optional<ClosestPolygonPoint> crossing_1_out_cpp = PolygonUtils::findClose(in_or_mid, outside, comber.getOutsideLocToLine(), close_to_penalty_function);
if (crossing_1_out_cpp)
{
out = PolygonUtils::moveOutside(*crossing_1_out_cpp, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
}
else
{
PolygonUtils::moveOutside(outside, out, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
}
}
int64_t in_out_dist2_1 = vSize2(out - in_or_mid);
if (dest_is_inside && in_out_dist2_1 > comber.max_crossing_dist2) // moveInside moved too far
{ // if move is too far over in_between
// find crossing closer by
assert(dest_crossing_poly && "destination crossing poly should have been instantiated!");
std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> best = findBestCrossing(outside, *dest_crossing_poly, dest_point, close_to, comber);
if (best)
{
in_or_mid = PolygonUtils::moveInside(best->first, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
out = PolygonUtils::moveOutside(best->second, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
}
if (fail_on_unavoidable_obstacles && vSize2(out - in_or_mid) > comber.max_crossing_dist2) // moveInside moved still too far
{
return false;
}
}
return true;
}
std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> Comb::Crossing::findBestCrossing(const Polygons& outside, const PolygonRef from, const Point estimated_start, const Point estimated_end, Comb& comber)
{
ClosestPolygonPoint* best_in = nullptr;
ClosestPolygonPoint* best_out = nullptr;
int64_t best_detour_score = std::numeric_limits<int64_t>::max();
int64_t best_crossing_dist2;
std::vector<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> crossing_out_candidates = PolygonUtils::findClose(from, outside, comber.getOutsideLocToLine());
bool seen_close_enough_connection = false;
for (std::pair<ClosestPolygonPoint, ClosestPolygonPoint>& crossing_candidate : crossing_out_candidates)
{
int64_t crossing_dist2 = vSize2(crossing_candidate.first.location - crossing_candidate.second.location);
if (crossing_dist2 > comber.max_crossing_dist2 * 2)
{ // preliminary filtering
continue;
}
int64_t dist_to_start = vSize(crossing_candidate.second.location - estimated_start); // use outside location, so that the crossing direction is taken into account
int64_t dist_to_end = vSize(crossing_candidate.second.location - estimated_end);
int64_t detour_dist = dist_to_start + dist_to_end;
int64_t detour_score = crossing_dist2 + detour_dist * detour_dist / 1000; // prefer a closest connection over a detour
// The detour distance is generally large compared to the crossing distance.
// While the crossing is generally about 1mm across,
// the distance between an arbitrary point and the boundary may well be a couple of centimetres.
// So the crossing_dist2 is about 1.000.000 while the detour_dist_2 is in the order of 400.000.000
// In the end we just want to choose between two points which have the _same_ crossing distance, modulo rounding error.
if ((!seen_close_enough_connection && detour_score < best_detour_score) // keep the best as long as we havent seen one close enough (so that we may walk along the polygon to find a closer connection from it in the code below)
|| (!seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2) // make the one which is close enough the best as soon as we see one close enough
|| (seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2 && detour_score < best_detour_score)) // update to keep the best crossing which is close enough already
{
if (!seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2)
{
seen_close_enough_connection = true;
}
best_in = &crossing_candidate.first;
best_out = &crossing_candidate.second;
best_detour_score = detour_score;
best_crossing_dist2 = crossing_dist2;
}
}
if (best_detour_score == std::numeric_limits<int64_t>::max())
{ // i.e. if best_in == nullptr or if best_out == nullptr
return std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>();
}
if (best_crossing_dist2 > comber.max_crossing_dist2)
{ // find closer point on line segments, rather than moving between vertices of the polygons only
PolygonUtils::walkToNearestSmallestConnection(*best_in, *best_out);
best_crossing_dist2 = vSize2(best_in->location - best_out->location);
if (best_crossing_dist2 > comber.max_crossing_dist2)
{
return std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>();
}
}
return std::make_shared<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>(*best_in, *best_out);
}
}//namespace cura
Revert "Also union layer polygons before combing"
This reverts commit 4aff5a14883e9695b47d777a7f52e9a76a8e32d4.
/** Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License */
#include "Comb.h"
#include <algorithm>
#include <functional> // function
#include <unordered_set>
#include "../utils/polygonUtils.h"
#include "../utils/PolygonsPointIndex.h"
#include "../sliceDataStorage.h"
#include "../utils/SVG.h"
namespace cura {
LocToLineGrid& Comb::getOutsideLocToLine()
{
return *outside_loc_to_line;
}
Polygons& Comb::getBoundaryOutside()
{
return *boundary_outside;
}
Comb::Comb(SliceDataStorage& storage, int layer_nr, Polygons& comb_boundary_inside, int64_t comb_boundary_offset, bool travel_avoid_other_parts, int64_t travel_avoid_distance)
: storage(storage)
, layer_nr(layer_nr)
, offset_from_outlines(comb_boundary_offset) // between second wall and infill / other walls
, max_moveInside_distance2(offset_from_outlines * 2 * offset_from_outlines * 2)
, offset_from_outlines_outside(travel_avoid_distance)
, offset_from_inside_to_outside(offset_from_outlines + offset_from_outlines_outside)
, max_crossing_dist2(offset_from_inside_to_outside * offset_from_inside_to_outside * 2) // so max_crossing_dist = offset_from_inside_to_outside * sqrt(2) =approx 1.5 to allow for slightly diagonal crossings and slightly inaccurate crossing computation
, avoid_other_parts(travel_avoid_other_parts)
, boundary_inside( comb_boundary_inside )
, partsView_inside( boundary_inside.splitIntoPartsView() ) // WARNING !! changes the order of boundary_inside !!
, inside_loc_to_line(PolygonUtils::createLocToLineGrid(boundary_inside, comb_boundary_offset))
, boundary_outside(
[&storage, layer_nr, travel_avoid_distance]()
{
return storage.getLayerOutlines(layer_nr, false).offset(travel_avoid_distance);
}
)
, outside_loc_to_line(
[](Comb* comber, const int64_t offset_from_inside_to_outside)
{
return PolygonUtils::createLocToLineGrid(comber->getBoundaryOutside(), offset_from_inside_to_outside * 3 / 2);
}
, this
, offset_from_inside_to_outside
)
{
}
Comb::~Comb()
{
if (inside_loc_to_line)
{
delete inside_loc_to_line;
}
}
bool Comb::calc(Point startPoint, Point endPoint, CombPaths& combPaths, bool _startInside, bool _endInside, int64_t max_comb_distance_ignored, bool via_outside_makes_combing_fail, bool fail_on_unavoidable_obstacles)
{
if (shorterThen(endPoint - startPoint, max_comb_distance_ignored))
{
return true;
}
//Move start and end point inside the comb boundary
unsigned int start_inside_poly = NO_INDEX;
const bool startInside = moveInside(_startInside, startPoint, start_inside_poly);
unsigned int end_inside_poly = NO_INDEX;
const bool endInside = moveInside(_endInside, endPoint, end_inside_poly);
unsigned int start_part_boundary_poly_idx;
unsigned int end_part_boundary_poly_idx;
unsigned int start_part_idx = (start_inside_poly == NO_INDEX)? NO_INDEX : partsView_inside.getPartContaining(start_inside_poly, &start_part_boundary_poly_idx);
unsigned int end_part_idx = (end_inside_poly == NO_INDEX)? NO_INDEX : partsView_inside.getPartContaining(end_inside_poly, &end_part_boundary_poly_idx);
if (startInside && endInside && start_part_idx == end_part_idx)
{ // normal combing within part
PolygonsPart part = partsView_inside.assemblePart(start_part_idx);
combPaths.emplace_back();
return LinePolygonsCrossings::comb(part, *inside_loc_to_line, startPoint, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
}
else
{ // comb inside part to edge (if needed) >> move through air avoiding other parts >> comb inside end part upto the endpoint (if needed)
// INSIDE | in_between | OUTSIDE | in_between | INSIDE
// ^crossing_1_in ^crossing_1_mid ^crossing_1_out ^crossing_2_out ^crossing_2_mid ^crossing_2_in
//
// when startPoint is inside crossing_1_in is of interest
// when it is in between inside and outside it is equal to crossing_1_mid
if (via_outside_makes_combing_fail)
{
return false;
}
Crossing start_crossing(startPoint, startInside, start_part_idx, start_part_boundary_poly_idx, boundary_inside, inside_loc_to_line);
Crossing end_crossing(endPoint, endInside, end_part_idx, end_part_boundary_poly_idx, boundary_inside, inside_loc_to_line);
{ // find crossing over the in-between area between inside and outside
start_crossing.findCrossingInOrMid(partsView_inside, endPoint);
end_crossing.findCrossingInOrMid(partsView_inside, start_crossing.in_or_mid);
}
bool skip_avoid_other_parts_path = false;
if (skip_avoid_other_parts_path && vSize2(start_crossing.in_or_mid - end_crossing.in_or_mid) < offset_from_inside_to_outside * offset_from_inside_to_outside * 4)
{ // parts are next to eachother, i.e. the direct crossing will always be smaller than two crossings via outside
skip_avoid_other_parts_path = true;
}
if (avoid_other_parts && !skip_avoid_other_parts_path)
{ // compute the crossing points when moving through air
// comb through all air, since generally the outside consists of a single part
bool success = start_crossing.findOutside(*boundary_outside, end_crossing.in_or_mid, fail_on_unavoidable_obstacles, *this);
if (!success)
{
return false;
}
success = end_crossing.findOutside(*boundary_outside, start_crossing.out, fail_on_unavoidable_obstacles, *this);
if (!success)
{
return false;
}
}
// generate the actual comb paths
if (startInside)
{
// start to boundary
assert(start_crossing.dest_part.size() > 0 && "The part we start inside when combing should have been computed already!");
combPaths.emplace_back();
bool combing_succeeded = LinePolygonsCrossings::comb(start_crossing.dest_part, *inside_loc_to_line, startPoint, start_crossing.in_or_mid, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
if (!combing_succeeded)
{ // Couldn't comb between start point and computed crossing from the start part! Happens for very thin parts when the offset_to_get_off_boundary moves points to outside the polygon
return false;
}
}
// throught air from boundary to boundary
if (avoid_other_parts && !skip_avoid_other_parts_path)
{
combPaths.emplace_back();
combPaths.throughAir = true;
if ( vSize(start_crossing.in_or_mid - end_crossing.in_or_mid) < vSize(start_crossing.in_or_mid - start_crossing.out) + vSize(end_crossing.in_or_mid - end_crossing.out) )
{ // via outside is moving more over the in-between zone
combPaths.back().push_back(start_crossing.in_or_mid);
combPaths.back().push_back(end_crossing.in_or_mid);
}
else
{
bool combing_succeeded = LinePolygonsCrossings::comb(*boundary_outside, *outside_loc_to_line, start_crossing.out, end_crossing.out, combPaths.back(), offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
if (!combing_succeeded)
{
return false;
}
}
}
else
{ // directly through air (not avoiding other parts)
combPaths.emplace_back();
combPaths.throughAir = true;
combPaths.back().cross_boundary = true; // note: we don't actually know whether this is cross boundary, but it might very well be
combPaths.back().push_back(start_crossing.in_or_mid);
combPaths.back().push_back(end_crossing.in_or_mid);
}
if (skip_avoid_other_parts_path)
{
if (startInside == endInside && start_part_idx == end_part_idx)
{
if (startInside)
{ // both start and end are inside
combPaths.back().cross_boundary = PolygonUtils::polygonCollidesWithLineSegment(startPoint, endPoint, *inside_loc_to_line);
}
else
{ // both start and end are outside
combPaths.back().cross_boundary = PolygonUtils::polygonCollidesWithLineSegment(startPoint, endPoint, *outside_loc_to_line);
}
}
else
{
combPaths.back().cross_boundary = true;
}
}
if (endInside)
{
// boundary to end
assert(end_crossing.dest_part.size() > 0 && "The part we end up inside when combing should have been computed already!");
combPaths.emplace_back();
bool combing_succeeded = LinePolygonsCrossings::comb(end_crossing.dest_part, *inside_loc_to_line, end_crossing.in_or_mid, endPoint, combPaths.back(), -offset_dist_to_get_from_on_the_polygon_to_outside, max_comb_distance_ignored, fail_on_unavoidable_obstacles);
if (!combing_succeeded)
{ // Couldn't comb between end point and computed crossing to the end part! Happens for very thin parts when the offset_to_get_off_boundary moves points to outside the polygon
return false;
}
}
return true;
}
}
Comb::Crossing::Crossing(const Point& dest_point, const bool dest_is_inside, const unsigned int dest_part_idx, const unsigned int dest_part_boundary_crossing_poly_idx, const Polygons& boundary_inside, const LocToLineGrid* inside_loc_to_line)
: dest_is_inside(dest_is_inside)
, boundary_inside(boundary_inside)
, inside_loc_to_line(inside_loc_to_line)
, dest_point(dest_point)
, dest_part_idx(dest_part_idx)
{
if (dest_is_inside)
{
dest_crossing_poly = boundary_inside[dest_part_boundary_crossing_poly_idx]; // initialize with most obvious poly, cause mostly a combing move will move outside the part, rather than inside a hole in the part
}
}
bool Comb::moveInside(bool is_inside, Point& dest_point, unsigned int& inside_poly)
{
if (is_inside)
{
ClosestPolygonPoint cpp = PolygonUtils::ensureInsideOrOutside(boundary_inside, dest_point, offset_extra_start_end, max_moveInside_distance2, &boundary_inside, inside_loc_to_line);
if (!cpp.isValid())
{
return false;
}
else
{
inside_poly = cpp.poly_idx;
return true;
}
}
return false;
}
void Comb::Crossing::findCrossingInOrMid(const PartsView& partsView_inside, const Point close_to)
{
if (dest_is_inside)
{ // in-case
// find the point on the start inside-polygon closest to the endpoint, but also kind of close to the start point
Point _dest_point(dest_point); // copy to local variable for lambda capture
std::function<int(Point)> close_towards_start_penalty_function([_dest_point](Point candidate){ return vSize2((candidate - _dest_point) / 10); });
dest_part = partsView_inside.assemblePart(dest_part_idx);
ClosestPolygonPoint boundary_crossing_point;
{ // set [result] to a point on the destination part closest to close_to (but also a bit close to _dest_point)
std::unordered_set<unsigned int> dest_part_poly_indices;
for (unsigned int poly_idx : partsView_inside[dest_part_idx])
{
dest_part_poly_indices.emplace(poly_idx);
}
coord_t dist2_score = std::numeric_limits<coord_t>::max();
std::function<bool (const PolygonsPointIndex&)> line_processor
= [close_to, _dest_point, &boundary_crossing_point, &dist2_score, &dest_part_poly_indices](const PolygonsPointIndex& boundary_segment)
{
if (dest_part_poly_indices.find(boundary_segment.poly_idx) == dest_part_poly_indices.end())
{ // we're not looking at a polygon from the dest_part
return true; // a.k.a. continue;
}
Point closest_here = LinearAlg2D::getClosestOnLineSegment(close_to, boundary_segment.p(), boundary_segment.next().p());
coord_t dist2_score_here = vSize2(close_to - closest_here) + vSize2(_dest_point - closest_here) / 10;
if (dist2_score_here < dist2_score)
{
dist2_score = dist2_score_here;
boundary_crossing_point = ClosestPolygonPoint(closest_here, boundary_segment.point_idx, boundary_segment.getPolygon(), boundary_segment.poly_idx);
}
return true;
};
inside_loc_to_line->processLine(std::make_pair(dest_point, close_to), line_processor);
}
Point result(boundary_crossing_point.p()); // the inside point of the crossing
if (!boundary_crossing_point.isValid())
{ // no point has been found in the sparse grid
result = dest_point;
}
int64_t max_dist2 = std::numeric_limits<int64_t>::max();
ClosestPolygonPoint crossing_1_in_cp = PolygonUtils::ensureInsideOrOutside(dest_part, result, boundary_crossing_point, offset_dist_to_get_from_on_the_polygon_to_outside, max_dist2, &boundary_inside, inside_loc_to_line, close_towards_start_penalty_function);
if (crossing_1_in_cp.isValid())
{
dest_crossing_poly = crossing_1_in_cp.poly;
in_or_mid = result;
}
else
{ // part is too small to be ensuring a point inside with the given distance
in_or_mid = dest_point; // just use the startPoint or endPoint itself
}
}
else
{
in_or_mid = dest_point; // mid-case
}
};
bool Comb::Crossing::findOutside(const Polygons& outside, const Point close_to, const bool fail_on_unavoidable_obstacles, Comb& comber)
{
out = in_or_mid;
if (dest_is_inside || outside.inside(in_or_mid, true)) // start in_between
{ // move outside
Point preferred_crossing_1_out = in_or_mid + normal(close_to - in_or_mid, comber.offset_from_inside_to_outside);
std::function<int(Point)> close_to_penalty_function([preferred_crossing_1_out](Point candidate){ return vSize2((candidate - preferred_crossing_1_out) / 2); });
std::optional<ClosestPolygonPoint> crossing_1_out_cpp = PolygonUtils::findClose(in_or_mid, outside, comber.getOutsideLocToLine(), close_to_penalty_function);
if (crossing_1_out_cpp)
{
out = PolygonUtils::moveOutside(*crossing_1_out_cpp, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
}
else
{
PolygonUtils::moveOutside(outside, out, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
}
}
int64_t in_out_dist2_1 = vSize2(out - in_or_mid);
if (dest_is_inside && in_out_dist2_1 > comber.max_crossing_dist2) // moveInside moved too far
{ // if move is too far over in_between
// find crossing closer by
assert(dest_crossing_poly && "destination crossing poly should have been instantiated!");
std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> best = findBestCrossing(outside, *dest_crossing_poly, dest_point, close_to, comber);
if (best)
{
in_or_mid = PolygonUtils::moveInside(best->first, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
out = PolygonUtils::moveOutside(best->second, comber.offset_dist_to_get_from_on_the_polygon_to_outside);
}
if (fail_on_unavoidable_obstacles && vSize2(out - in_or_mid) > comber.max_crossing_dist2) // moveInside moved still too far
{
return false;
}
}
return true;
}
std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> Comb::Crossing::findBestCrossing(const Polygons& outside, const PolygonRef from, const Point estimated_start, const Point estimated_end, Comb& comber)
{
ClosestPolygonPoint* best_in = nullptr;
ClosestPolygonPoint* best_out = nullptr;
int64_t best_detour_score = std::numeric_limits<int64_t>::max();
int64_t best_crossing_dist2;
std::vector<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>> crossing_out_candidates = PolygonUtils::findClose(from, outside, comber.getOutsideLocToLine());
bool seen_close_enough_connection = false;
for (std::pair<ClosestPolygonPoint, ClosestPolygonPoint>& crossing_candidate : crossing_out_candidates)
{
int64_t crossing_dist2 = vSize2(crossing_candidate.first.location - crossing_candidate.second.location);
if (crossing_dist2 > comber.max_crossing_dist2 * 2)
{ // preliminary filtering
continue;
}
int64_t dist_to_start = vSize(crossing_candidate.second.location - estimated_start); // use outside location, so that the crossing direction is taken into account
int64_t dist_to_end = vSize(crossing_candidate.second.location - estimated_end);
int64_t detour_dist = dist_to_start + dist_to_end;
int64_t detour_score = crossing_dist2 + detour_dist * detour_dist / 1000; // prefer a closest connection over a detour
// The detour distance is generally large compared to the crossing distance.
// While the crossing is generally about 1mm across,
// the distance between an arbitrary point and the boundary may well be a couple of centimetres.
// So the crossing_dist2 is about 1.000.000 while the detour_dist_2 is in the order of 400.000.000
// In the end we just want to choose between two points which have the _same_ crossing distance, modulo rounding error.
if ((!seen_close_enough_connection && detour_score < best_detour_score) // keep the best as long as we havent seen one close enough (so that we may walk along the polygon to find a closer connection from it in the code below)
|| (!seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2) // make the one which is close enough the best as soon as we see one close enough
|| (seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2 && detour_score < best_detour_score)) // update to keep the best crossing which is close enough already
{
if (!seen_close_enough_connection && crossing_dist2 <= comber.max_crossing_dist2)
{
seen_close_enough_connection = true;
}
best_in = &crossing_candidate.first;
best_out = &crossing_candidate.second;
best_detour_score = detour_score;
best_crossing_dist2 = crossing_dist2;
}
}
if (best_detour_score == std::numeric_limits<int64_t>::max())
{ // i.e. if best_in == nullptr or if best_out == nullptr
return std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>();
}
if (best_crossing_dist2 > comber.max_crossing_dist2)
{ // find closer point on line segments, rather than moving between vertices of the polygons only
PolygonUtils::walkToNearestSmallestConnection(*best_in, *best_out);
best_crossing_dist2 = vSize2(best_in->location - best_out->location);
if (best_crossing_dist2 > comber.max_crossing_dist2)
{
return std::shared_ptr<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>();
}
}
return std::make_shared<std::pair<ClosestPolygonPoint, ClosestPolygonPoint>>(*best_in, *best_out);
}
}//namespace cura
|
/*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
* These are misc unit tests for header rewrite
*/
#include <cstdio>
#include <cstdarg>
#include <parser.h>
const char PLUGIN_NAME[] = "TEST_header_rewrite";
const char PLUGIN_NAME_DBG[] = "TEST_dbg_header_rewrite";
extern "C" void TSError(const char* fmt, ...) {
char buf[2048];
int bytes = 0;
va_list args;
va_start (args, fmt);
if((bytes = vsnprintf (buf, sizeof(buf), fmt, args)) > 0) {
fprintf(stderr, "TSError: %s: %.*s\n", PLUGIN_NAME, bytes, buf);
}
}
extern "C" void TSDebug(const char *tag, const char* fmt, ...) {
char buf[2048];
int bytes = 0;
va_list args;
va_start (args, fmt);
if((bytes = vsnprintf (buf, sizeof(buf), fmt, args)) > 0) {
fprintf(stdout, "TSDebug: %s: %.*s\n", PLUGIN_NAME, bytes, buf);
}
}
#define CHECK_EQ(x, y) \
do { \
if ( (x) != (y) ) { \
fprintf(stderr, "CHECK FAILED " #x " != " #y "\n"); \
return 1; \
} \
} while (false);
class ParserTest : public Parser {
public:
ParserTest(std::string line) : Parser(line) { }
std::vector<std::string> getTokens() {
return _tokens;
}
};
int test_parsing() {
{
ParserTest p("cond %{READ_REQUEST_HDR_HOOK}");
CHECK_EQ(p.getTokens().size(), 2);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{READ_REQUEST_HDR_HOOK}");
}
{
ParserTest p("cond %{CLIENT-HEADER:Host} =a");
CHECK_EQ(p.getTokens().size(), 4);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:Host}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "a");
}
{
ParserTest p(" # COMMENT!");
CHECK_EQ(p.getTokens().size(), 0);
CHECK_EQ(p.empty(), true);
}
{
ParserTest p("# COMMENT");
CHECK_EQ(p.getTokens().size(), 0);
CHECK_EQ(p.empty(), true);
}
{
ParserTest p("cond %{Client-HEADER:Foo} =b");
CHECK_EQ(p.getTokens().size(), 4);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{Client-HEADER:Foo}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "b");
}
{
ParserTest p("cond %{Client-HEADER:Blah} = x");
CHECK_EQ(p.getTokens().size(), 4);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{Client-HEADER:Blah}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "x");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} = \"shouldnt_ exist _anyway\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "shouldnt_ exist _anyway");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} = \"shouldnt_ = _anyway\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "shouldnt_ = _anyway");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\"=\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "=");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\"\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("add-header X-HeaderRewriteApplied true");
CHECK_EQ(p.getTokens().size(), 3);
CHECK_EQ(p.getTokens()[0], "add-header");
CHECK_EQ(p.getTokens()[1], "X-HeaderRewriteApplied");
CHECK_EQ(p.getTokens()[2], "true");
}
/*
* test some failure scenarios
*/
{ /* unterminated quote */
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\" [AND]");
CHECK_EQ(p.getTokens().size(), 0);
}
{ /* quote in a token */
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =a\"b [AND]");
CHECK_EQ(p.getTokens().size(), 0);
}
return 0;
}
int test_processing() {
/*
* These tests are designed to verify that the processing of the parsed input is correct.
*/
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\"=\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.get_op(), "CLIENT-HEADER:non_existent_header");
CHECK_EQ(p.get_arg(), "==");
CHECK_EQ(p.is_cond(), true);
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} = \"shouldnt_ = _anyway\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.get_op(), "CLIENT-HEADER:non_existent_header");
CHECK_EQ(p.get_arg(), "=shouldnt_ = _anyway");
CHECK_EQ(p.is_cond(), true);
}
{
ParserTest p("add-header X-HeaderRewriteApplied true");
CHECK_EQ(p.getTokens().size(), 3);
CHECK_EQ(p.get_op(), "add-header");
CHECK_EQ(p.get_arg(), "X-HeaderRewriteApplied");
CHECK_EQ(p.get_value(), "true")
CHECK_EQ(p.is_cond(), false);
}
return 0;
}
int tests() {
if (test_parsing() ||
test_processing()) {
return 1;
}
return 0;
}
int main () {
return tests();
}
TS-3956: Header_rewrite applies strange logic with = operator, remove %{} which breaks printf
/*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
* These are misc unit tests for header rewrite
*/
#include <cstdio>
#include <cstdarg>
#include <parser.h>
const char PLUGIN_NAME[] = "TEST_header_rewrite";
const char PLUGIN_NAME_DBG[] = "TEST_dbg_header_rewrite";
extern "C" void TSError(const char* fmt, ...) {
char buf[2048];
int bytes = 0;
va_list args;
va_start (args, fmt);
if((bytes = vsnprintf (buf, sizeof(buf), fmt, args)) > 0) {
fprintf(stderr, "TSError: %s: %.*s\n", PLUGIN_NAME, bytes, buf);
}
}
extern "C" void TSDebug(const char *tag, const char* fmt, ...) {
char buf[2048];
int bytes = 0;
va_list args;
va_start (args, fmt);
if((bytes = vsnprintf (buf, sizeof(buf), fmt, args)) > 0) {
fprintf(stdout, "TSDebug: %s: %.*s\n", PLUGIN_NAME, bytes, buf);
}
}
#define CHECK_EQ(x, y) \
do { \
if ( (x) != (y) ) { \
fprintf(stderr, "CHECK FAILED\n"); \
return 1; \
} \
} while (false);
class ParserTest : public Parser {
public:
ParserTest(std::string line) : Parser(line) { }
std::vector<std::string> getTokens() {
return _tokens;
}
};
int test_parsing() {
{
ParserTest p("cond %{READ_REQUEST_HDR_HOOK}");
CHECK_EQ(p.getTokens().size(), 2);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{READ_REQUEST_HDR_HOOK}");
}
{
ParserTest p("cond %{CLIENT-HEADER:Host} =a");
CHECK_EQ(p.getTokens().size(), 4);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:Host}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "a");
}
{
ParserTest p(" # COMMENT!");
CHECK_EQ(p.getTokens().size(), 0);
CHECK_EQ(p.empty(), true);
}
{
ParserTest p("# COMMENT");
CHECK_EQ(p.getTokens().size(), 0);
CHECK_EQ(p.empty(), true);
}
{
ParserTest p("cond %{Client-HEADER:Foo} =b");
CHECK_EQ(p.getTokens().size(), 4);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{Client-HEADER:Foo}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "b");
}
{
ParserTest p("cond %{Client-HEADER:Blah} = x");
CHECK_EQ(p.getTokens().size(), 4);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{Client-HEADER:Blah}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "x");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} = \"shouldnt_ exist _anyway\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "shouldnt_ exist _anyway");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} = \"shouldnt_ = _anyway\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "shouldnt_ = _anyway");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\"=\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "=");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\"\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.getTokens()[0], "cond");
CHECK_EQ(p.getTokens()[1], "%{CLIENT-HEADER:non_existent_header}");
CHECK_EQ(p.getTokens()[2], "=");
CHECK_EQ(p.getTokens()[3], "");
CHECK_EQ(p.getTokens()[4], "[AND]");
}
{
ParserTest p("add-header X-HeaderRewriteApplied true");
CHECK_EQ(p.getTokens().size(), 3);
CHECK_EQ(p.getTokens()[0], "add-header");
CHECK_EQ(p.getTokens()[1], "X-HeaderRewriteApplied");
CHECK_EQ(p.getTokens()[2], "true");
}
/*
* test some failure scenarios
*/
{ /* unterminated quote */
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\" [AND]");
CHECK_EQ(p.getTokens().size(), 0);
}
{ /* quote in a token */
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =a\"b [AND]");
CHECK_EQ(p.getTokens().size(), 0);
}
return 0;
}
int test_processing() {
/*
* These tests are designed to verify that the processing of the parsed input is correct.
*/
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} =\"=\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.get_op(), "CLIENT-HEADER:non_existent_header");
CHECK_EQ(p.get_arg(), "==");
CHECK_EQ(p.is_cond(), true);
}
{
ParserTest p("cond %{CLIENT-HEADER:non_existent_header} = \"shouldnt_ = _anyway\" [AND]");
CHECK_EQ(p.getTokens().size(), 5);
CHECK_EQ(p.get_op(), "CLIENT-HEADER:non_existent_header");
CHECK_EQ(p.get_arg(), "=shouldnt_ = _anyway");
CHECK_EQ(p.is_cond(), true);
}
{
ParserTest p("add-header X-HeaderRewriteApplied true");
CHECK_EQ(p.getTokens().size(), 3);
CHECK_EQ(p.get_op(), "add-header");
CHECK_EQ(p.get_arg(), "X-HeaderRewriteApplied");
CHECK_EQ(p.get_value(), "true")
CHECK_EQ(p.is_cond(), false);
}
return 0;
}
int tests() {
if (test_parsing() ||
test_processing()) {
return 1;
}
return 0;
}
int main () {
return tests();
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//util classes
struct Input {
int r, c, l, h;
vector<vector<bool>> tomatoes;
};
struct Slice {
int r1, c1, r2, c2;
};
struct Output {
vector<Slice> slices;
};
void solveSimple(Input& input, Output& output) {
for (int i = 0; i < input.r; i++)
{
for (int j = 0; j < input.c; j += input.h)
{
Slice s;
s.r1 = i;
s.c1 = j;
s.r2 = i;
s.c2 = min(j+input.h-1, input.c-1);
output.slices.push_back(s);
}
}
}
int add_slice(const vector<bool> &a, int l, int r) {
int cnt1 = 0, cnt2 = 0;
for (int i = l; i <= r; i++)
if (a[i])
cnt1++;
else
cnt2++;
if (cnt1 >= l && cnt2 >= l)
return r-l+1;
return 0;
}
void solve_row(const vector<bool> &a, int row_index, int n, int l, int h, vector<slices> &ans) {
vector<int> d(n,0), prev(n,0);
for (int i = 0; i < n; i++)
for (int j = 2*l; j <= h; j++)
if (i-j+1 >= 0)
{
int temp = add_slice(a,i-j+1,i))
if (d[i] < d[i-j+1] + temp)
{
d[i] = d[i-j+1] + temp;
prev[i] = i-j+1;
}
}
int i_max = 0;
for (int i = 0; i < n; i++)
if (d[i] > d[i_max])
i_max = i;
Slice c;
c.r1 = c.r2 = row_num;
for (int i = i_max; i > 0; i--)
{
c.c1 = prev[i]; c.c2 = i;
i = prev[i]-1;
slices.push_back(c);
}
}
void solveDP(Input& input, Output& output) {
for (int i = 0; i < r; i++)
solve_row(input.tomatoes[i],i,input.c,input.l,input.h,output.slices);
}
//input/output code
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
//read input
Input input;
cin >> input.r >> input.c >> input.l >> input.h;
for(int i = 0; i < input.r; i++) {
vector<bool> row(input.c);
for(int j = 0; j < input.c; j++) {
char cell;
cin >> cell;
row[j] = cell == 'T';
}
input.tomatoes.push_back(row);
//TODO do we read line breaks?
}
//read command line args
string algorithm = "simple";
if(argc > 2) {
algorithm = argv[1];
}
//solve problem
Output output;
if(algorithm == "simple") {
solveSimple(input, output);
}
else if(algorithm == "dp") {
solveDP(input, output);
}
else {
cerr << "unknown algorithm " << algorithm << endl;
return 1;
}
//print output
cout << output.slices.size() << endl;
for(Slice slice: output.slices) {
cout << slice.r1 << ' ' << slice.c1 << ' ' << slice.r2 << ' ' << slice.c2 << endl;
}
};
fix syntax errors by Kirill ;)
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//util classes
struct Input {
int r, c, l, h;
vector<vector<bool>> tomatoes;
};
struct Slice {
int r1, c1, r2, c2;
};
struct Output {
vector<Slice> slices;
};
void solveSimple(Input& input, Output& output) {
for (int i = 0; i < input.r; i++)
{
for (int j = 0; j < input.c; j += input.h)
{
Slice s;
s.r1 = i;
s.c1 = j;
s.r2 = i;
s.c2 = min(j+input.h-1, input.c-1);
output.slices.push_back(s);
}
}
}
int add_slice(const vector<bool> &a, int l, int r) {
int cnt1 = 0, cnt2 = 0;
for (int i = l; i <= r; i++)
if (a[i])
cnt1++;
else
cnt2++;
if (cnt1 >= l && cnt2 >= l)
return r-l+1;
return 0;
}
void solve_row(const vector<bool> &a, int row_num, int n, int l, int h, vector<Slice> &ans) {
vector<int> d(n,0), prev(n,0);
for (int i = 0; i < n; i++)
for (int j = 2*l; j <= h; j++)
if (i-j+1 >= 0)
{
int temp = add_slice(a,i-j+1,i);
if (d[i] < d[i-j+1] + temp)
{
d[i] = d[i-j+1] + temp;
prev[i] = i-j+1;
}
}
int i_max = 0;
for (int i = 0; i < n; i++)
if (d[i] > d[i_max])
i_max = i;
Slice c;
c.r1 = c.r2 = row_num;
for (int i = i_max; i > 0; i--)
{
c.c1 = prev[i]; c.c2 = i;
i = prev[i]-1;
ans.push_back(c);
}
}
void solveDP(Input& input, Output& output) {
for (int i = 0; i < input.r; i++)
solve_row(input.tomatoes[i],i,input.c,input.l,input.h,output.slices);
}
//input/output code
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
//read input
Input input;
cin >> input.r >> input.c >> input.l >> input.h;
for(int i = 0; i < input.r; i++) {
vector<bool> row(input.c);
for(int j = 0; j < input.c; j++) {
char cell;
cin >> cell;
row[j] = cell == 'T';
}
input.tomatoes.push_back(row);
//TODO do we read line breaks?
}
//read command line args
string algorithm = "simple";
if(argc > 2) {
algorithm = argv[1];
}
//solve problem
Output output;
if(algorithm == "simple") {
solveSimple(input, output);
}
else if(algorithm == "dp") {
solveDP(input, output);
}
else {
cerr << "unknown algorithm " << algorithm << endl;
return 1;
}
//print output
cout << output.slices.size() << endl;
for(Slice slice: output.slices) {
cout << slice.r1 << ' ' << slice.c1 << ' ' << slice.r2 << ' ' << slice.c2 << endl;
}
};
|
/// @file Terrain.cpp
/// @brief Performs IDCT decompression on terrain height map data.
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// For conditions of distribution and use, see copyright notice in license.txt
#include "StableHeaders.h"
#include "BitStream.h"
#include "Terrain.h"
using namespace Core;
namespace RexLogic
{
namespace
{
const int cEndOfPatches = 97; ///< Magic number that denotes in a LayerData header that there are no more patches present in the packet.
const float OO_SQRT2 = 0.7071067811865475244008443621049f;
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Stores precomputed tables of coefficients needed in the IDCT transform.
class IDCTPrecomputationTables
{
public:
IDCTPrecomputationTables()
{
BuildDequantizeTable16();
BuildQuantizeTable16();
SetupCosines16();
BuildCopyMatrix16();
}
float dequantizeTable16[16*16];
float cosineTable16[16*16];
int copyMatrix16[16*16];
float quantizeTable16[16*16];
void BuildDequantizeTable16()
{
for (int j = 0; j < 16; j++)
for (int i = 0; i < 16; i++)
dequantizeTable16[j*16 + i] = 1.0f + 2.0f * (float)(i + j);
}
void BuildQuantizeTable16()
{
for (int j = 0; j < 16; j++)
for (int i = 0; i < 16; i++)
quantizeTable16[j*16 + i] = 1.0f / (1.0f + 2.0f * ((float)i + (float)j));
}
void SetupCosines16()
{
const float hposz = PI * 0.5f / 16.0f;
for (int u = 0; u < 16; u++)
for (int n = 0; n < 16; n++)
cosineTable16[u*16 + n] = (float)cosf((2.0f * (float)n + 1.0f) * (float)u * hposz);
}
void BuildCopyMatrix16()
{
bool diag = false;
bool right = true;
int i = 0;
int j = 0;
int count = 0;
while (i < 16 && j < 16)
{
copyMatrix16[j * 16 + i] = count++;
if (!diag)
{
if (right)
{
if (i < 16 - 1) i++;
else j++;
right = false;
diag = true;
}
else
{
if (j < 16 - 1) j++;
else i++;
right = true;
diag = true;
}
}
else
{
if (right)
{
i++;
j--;
if (i == 16 - 1 || j == 0) diag = false;
}
else
{
i--;
j++;
if (j == 16 - 1 || i == 0) diag = false;
}
}
}
}
};
/// These tables will be used by the IDCT routines. The ctor builds the tables and only this instance is accessed by the routines.
const IDCTPrecomputationTables precompTables;
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Extracts and returns the header for a single terrain patch in the LayerData stream.
TerrainPatchHeader DecodePatchHeader(BitStream &bits)
{
TerrainPatchHeader header;
header.quantWBits = bits.ReadBits(8);
if (header.quantWBits == cEndOfPatches)
return header;
u32 val = bits.ReadBits(32);
header.dcOffset = *reinterpret_cast<float*>(&val);
header.range = bits.ReadBits(16);
header.x = bits.ReadBits(5);
header.y = bits.ReadBits(5);
header.wordBits = (uint)((header.quantWBits & 0x0f) + 2); // This is a bit odd - apparently this field is not present in the header?
return header;
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// @param patches [out] The resulting patch data will be output here. The size of this buffer must be >= size*size.
/// @param size The number of points in the patch in one direction (patches are square).
void DecodeTerrainPatch(int *patches, BitStream &bits, const TerrainPatchHeader &header, int size)
{
for(int i = 0; i < size * size; ++i)
{
bool v = bits.ReadBit(); // 'Patches present' flag?
if (!v)
{
patches[i] = 0;
continue;
}
v = bits.ReadBit(); // 'End of patch data' flag?
if (!v)
{
for(; i < size * size; ++i)
patches[i] = 0;
return;
}
bool signNegative = bits.ReadBit();
s32 data = (s32)bits.ReadBits(header.wordBits);
patches[i] = signNegative ? -data : data;
}
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Performs IDCT on a single column of 16 elements of data. (stride assumed to be 16 elements)
void IDCTColumn16(const float *linein, float *lineout, int column)
{
float total;
const int cStride = 16;
for (int n = 0; n < 16; n++)
{
total = OO_SQRT2 * linein[column];
for (int u = 1; u < 16; u++)
total += linein[u*cStride + column] * precompTables.cosineTable16[u*cStride + n];
lineout[16 * n + column] = total;
}
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Performs IDCT on a single row of 16 elements of data.
void IDCTLine16(const float *linein, float *lineout, int line)
{
const float oosob = 2.0f / 16.0f;
int lineSize = line * 16;
float total;
for (int n = 0; n < 16; n++)
{
total = OO_SQRT2 * linein[lineSize];
for (int u = 1; u < 16; u++)
{
total += linein[lineSize + u] * precompTables.cosineTable16[u * 16 + n];
}
lineout[lineSize + n] = total * oosob;
}
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
void DecompressTerrainPatch(std::vector<float> &output, int *patchData, const TerrainPatchHeader &patchHeader, const TerrainPatchGroupHeader &groupHeader)
{
std::vector<float> block(groupHeader.patchSize * groupHeader.patchSize);
output.clear();
output.resize(groupHeader.patchSize * groupHeader.patchSize);
int prequant = (patchHeader.quantWBits >> 4) + 2;
int quantize = 1 << prequant;
float ooq = 1.0f / (float)quantize;
float mult = ooq * (float)patchHeader.range;
float addval = mult * (float)(1 << (prequant - 1)) + patchHeader.dcOffset;
if (groupHeader.patchSize != 16)
{
///\todo Output log warning - unsupported patch size present!
return;
}
for(int n = 0; n < 16 * 16; n++)
block[n] = patchData[precompTables.copyMatrix16[n]] * precompTables.dequantizeTable16[n];
std::vector<float> ftemp(16*16);
for (int o = 0; o < 16; o++)
IDCTColumn16(&block[0], &ftemp[0], o);
for (int o = 0; o < 16; o++)
IDCTLine16(&ftemp[0], &block[0], o);
for (int j = 0; j < block.size(); j++)
output[j] = block[j] * mult + addval;
}
} // ~unnamed namespace
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
void DecompressLand(BitStream &bits, const TerrainPatchGroupHeader &groupHeader)
{
while(bits.BitsLeft() > 0)
{
TerrainPatchHeader patchHeader = DecodePatchHeader(bits);
if (patchHeader.quantWBits == cEndOfPatches)
break;
const int cPatchesPerEdge = 16;
// The MSB of header.x and header.y are unused, or used for some other purpose?
if (patchHeader.x >= cPatchesPerEdge || patchHeader.y >= cPatchesPerEdge)
{
///\todo Log out warning - invalid packet?
return;
}
int patchData[32*32];
DecodeTerrainPatch(patchData, bits, patchHeader, groupHeader.patchSize);
std::vector<float> heightData;
DecompressTerrainPatch(heightData, patchData, patchHeader, groupHeader);
}
}
}
GCC fixes.
git-svn-id: 65dd0ccd495961f396d5302e5521154b071f0302@408 5b2332b8-efa3-11de-8684-7d64432d61a3
/// @file Terrain.cpp
/// @brief Performs IDCT decompression on terrain height map data.
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// For conditions of distribution and use, see copyright notice in license.txt
#include "StableHeaders.h"
#include "BitStream.h"
#include "Terrain.h"
using namespace Core;
namespace RexLogic
{
namespace
{
const int cEndOfPatches = 97; ///< Magic number that denotes in a LayerData header that there are no more patches present in the packet.
const float OO_SQRT2 = 0.7071067811865475244008443621049f;
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Stores precomputed tables of coefficients needed in the IDCT transform.
class IDCTPrecomputationTables
{
public:
IDCTPrecomputationTables()
{
BuildDequantizeTable16();
BuildQuantizeTable16();
SetupCosines16();
BuildCopyMatrix16();
}
float dequantizeTable16[16*16];
float cosineTable16[16*16];
int copyMatrix16[16*16];
float quantizeTable16[16*16];
void BuildDequantizeTable16()
{
for (int j = 0; j < 16; j++)
for (int i = 0; i < 16; i++)
dequantizeTable16[j*16 + i] = 1.0f + 2.0f * (float)(i + j);
}
void BuildQuantizeTable16()
{
for (int j = 0; j < 16; j++)
for (int i = 0; i < 16; i++)
quantizeTable16[j*16 + i] = 1.0f / (1.0f + 2.0f * ((float)i + (float)j));
}
void SetupCosines16()
{
const float hposz = PI * 0.5f / 16.0f;
for (int u = 0; u < 16; u++)
for (int n = 0; n < 16; n++)
cosineTable16[u*16 + n] = (float)cosf((2.0f * (float)n + 1.0f) * (float)u * hposz);
}
void BuildCopyMatrix16()
{
bool diag = false;
bool right = true;
int i = 0;
int j = 0;
int count = 0;
while (i < 16 && j < 16)
{
copyMatrix16[j * 16 + i] = count++;
if (!diag)
{
if (right)
{
if (i < 16 - 1) i++;
else j++;
right = false;
diag = true;
}
else
{
if (j < 16 - 1) j++;
else i++;
right = true;
diag = true;
}
}
else
{
if (right)
{
i++;
j--;
if (i == 16 - 1 || j == 0) diag = false;
}
else
{
i--;
j++;
if (j == 16 - 1 || i == 0) diag = false;
}
}
}
}
};
/// These tables will be used by the IDCT routines. The ctor builds the tables and only this instance is accessed by the routines.
const IDCTPrecomputationTables precompTables;
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Extracts and returns the header for a single terrain patch in the LayerData stream.
TerrainPatchHeader DecodePatchHeader(BitStream &bits)
{
TerrainPatchHeader header;
header.quantWBits = bits.ReadBits(8);
if (header.quantWBits == cEndOfPatches)
return header;
u32 val = bits.ReadBits(32);
header.dcOffset = *reinterpret_cast<float*>(&val);
header.range = bits.ReadBits(16);
header.x = bits.ReadBits(5);
header.y = bits.ReadBits(5);
header.wordBits = (Core::uint)((header.quantWBits & 0x0f) + 2); // This is a bit odd - apparently this field is not present in the header?
return header;
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// @param patches [out] The resulting patch data will be output here. The size of this buffer must be >= size*size.
/// @param size The number of points in the patch in one direction (patches are square).
void DecodeTerrainPatch(int *patches, BitStream &bits, const TerrainPatchHeader &header, int size)
{
for(int i = 0; i < size * size; ++i)
{
bool v = bits.ReadBit(); // 'Patches present' flag?
if (!v)
{
patches[i] = 0;
continue;
}
v = bits.ReadBit(); // 'End of patch data' flag?
if (!v)
{
for(; i < size * size; ++i)
patches[i] = 0;
return;
}
bool signNegative = bits.ReadBit();
s32 data = (s32)bits.ReadBits(header.wordBits);
patches[i] = signNegative ? -data : data;
}
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Performs IDCT on a single column of 16 elements of data. (stride assumed to be 16 elements)
void IDCTColumn16(const float *linein, float *lineout, int column)
{
float total;
const int cStride = 16;
for (int n = 0; n < 16; n++)
{
total = OO_SQRT2 * linein[column];
for (int u = 1; u < 16; u++)
total += linein[u*cStride + column] * precompTables.cosineTable16[u*cStride + n];
lineout[16 * n + column] = total;
}
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
/// Performs IDCT on a single row of 16 elements of data.
void IDCTLine16(const float *linein, float *lineout, int line)
{
const float oosob = 2.0f / 16.0f;
int lineSize = line * 16;
float total;
for (int n = 0; n < 16; n++)
{
total = OO_SQRT2 * linein[lineSize];
for (int u = 1; u < 16; u++)
{
total += linein[lineSize + u] * precompTables.cosineTable16[u * 16 + n];
}
lineout[lineSize + n] = total * oosob;
}
}
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
void DecompressTerrainPatch(std::vector<float> &output, int *patchData, const TerrainPatchHeader &patchHeader, const TerrainPatchGroupHeader &groupHeader)
{
std::vector<float> block(groupHeader.patchSize * groupHeader.patchSize);
output.clear();
output.resize(groupHeader.patchSize * groupHeader.patchSize);
int prequant = (patchHeader.quantWBits >> 4) + 2;
int quantize = 1 << prequant;
float ooq = 1.0f / (float)quantize;
float mult = ooq * (float)patchHeader.range;
float addval = mult * (float)(1 << (prequant - 1)) + patchHeader.dcOffset;
if (groupHeader.patchSize != 16)
{
///\todo Output log warning - unsupported patch size present!
return;
}
for(int n = 0; n < 16 * 16; n++)
block[n] = patchData[precompTables.copyMatrix16[n]] * precompTables.dequantizeTable16[n];
std::vector<float> ftemp(16*16);
for (int o = 0; o < 16; o++)
IDCTColumn16(&block[0], &ftemp[0], o);
for (int o = 0; o < 16; o++)
IDCTLine16(&ftemp[0], &block[0], o);
for (int j = 0; j < block.size(); j++)
output[j] = block[j] * mult + addval;
}
} // ~unnamed namespace
/// Code adapted from libopenmetaverse.org project, TerrainCompressor.cs / TerrainManager.cs
void DecompressLand(BitStream &bits, const TerrainPatchGroupHeader &groupHeader)
{
while(bits.BitsLeft() > 0)
{
TerrainPatchHeader patchHeader = DecodePatchHeader(bits);
if (patchHeader.quantWBits == cEndOfPatches)
break;
const int cPatchesPerEdge = 16;
// The MSB of header.x and header.y are unused, or used for some other purpose?
if (patchHeader.x >= cPatchesPerEdge || patchHeader.y >= cPatchesPerEdge)
{
///\todo Log out warning - invalid packet?
return;
}
int patchData[32*32];
DecodeTerrainPatch(patchData, bits, patchHeader, groupHeader.patchSize);
std::vector<float> heightData;
DecompressTerrainPatch(heightData, patchData, patchHeader, groupHeader);
}
}
}
|
/////////////////////////////////////////////////////////////////////////
//
// SneezyMUD - All rights reserved, SneezyMUD Coding Team
// "range.cc" - All functions and routines related to ranged combat
//
// Ranged systems coded by Russ Russell and Benjamin Youngdahl
//
/////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <map>
#include "stdsneezy.h"
#include "range.h"
#include "combat.h"
#include "obj_quiver.h"
#include "obj_bow.h"
#include "obj_portal.h"
#include "obj_arrow.h"
#include "obj_gun.h"
#define RANGE_DEBUG 0
const char *directions[][2] =
{
{"north", "from the south"},
{"east", "from the west"},
{"south", "from the north"},
{"west", "from the east"},
{"up", "from below"},
{"down", "from above"},
{"northeast", "from the southwest"},
{"northwest", "from the southeast"},
{"southeast", "from the northwest"},
{"southwest", "from the northeast"}
};
const char *dir_name[] =
{
"the north",
"the east",
"the south",
"the west",
"above",
"below",
"the northeast",
"the northwest",
"the southeast",
"the southwest",
};
int TThing::throwMe(TBeing *ch, dirTypeT tdir, const char *vict)
{
int iDist, rc;
unsigned int max_distance;
double mult;
TBeing *targ;
TThing *tmp;
unsigned int count;
char local_vict[256];
// a little physics....
// let the force I can throw something with be a function of my brawn
// F = f(brawn) = mass * accelleration
// acc = f(brawn)/m
float acc = ch->plotStat(STAT_CURRENT, STAT_BRA, 500.0, 5000.0, 2500.0);
acc /= max((float) 3.0, getWeight());
// regard acc as a ft/sec^2
// assume a throw has this constant acceleration for 0.2 secs
// which yields a final velocity v0x
float v0 = 0.2 * acc;
// regard this as ft/sec
// note, the values for acc's plotStat are roughly to correspond to
// avg human = 65 mph fastball, best human = 90 mph fast ball
// we fufged it and pretended baseball = 5lb (same as training dag)
// let's assume that they throw the object semi level to ground (no up angle)
// time aloft is then given by: h = 1/2 gt^2
// h being height thrown from, g = gravity
// using Earth's gravity of 32 ft/sec^2 and converting height to feet
float tt = sqrt(2 * (ch->getPartMinHeight(ITEM_WEAR_NECK)/12.0) / 32.0);
// regard this as secs
// lets toss in some "smarts" checking
// the above assumed the trajectory was at an up angle of 0 degrees
// if the thrower is smart, he'll realize he can throw further with an
// up angle. Since they are trying to hit a fixed distance target, they
// are really trying to solve a trajectory. This ain't easy so make the
// allowed angle be a function of int.
// 45 degrees is obscene range
int ang = ch->plotStat(STAT_CURRENT, STAT_FOC, 0, 45, 5);
// figure out the limiting angle
// i.e. above angle assumes I can safely throw a ballistic arc
// ceilings would prevent this...
if (ch->roomp->getRoomHeight() >= 0) {
// vf^2 = 2ax
// (vo sin(lim_ang))^2 = 2 * 32.0 * (room_height - my height)
float lim_ang = sqrt(2 * 32.0 * (ch->roomp->getRoomHeight() - ch->getPartMinHeight(ITEM_WEAR_NECK))/12.0 / v0 / v0);
lim_ang = asin(lim_ang);
lim_ang = lim_ang * 360.0 / 2 / M_PI; // convert from radians
ang = min(ang, (int) lim_ang);
}
ang = min(max(ang, 0), 45);
// and FINALLY, we translate all this into a range...
// the upangle range = v0^2/g sin 2(ang)
mult = ((v0 * v0)/32.0) * sin(2*ang*(2.0*M_PI/360.0));
// the above formula is for returning to same height we started from
// make allowance for how high we started from (from tt above)
mult += v0 * cos(ang * (2.0*M_PI/360.0)) * tt;
// regard the average "room" as 50 feet across, exterior = 100 ft across
if (ch->outside())
max_distance = (unsigned int) (mult / 100);
else
max_distance = (unsigned int) (mult / 50);
// this results in typical max distances of 3-4 rooms
// arbitrarily scale it so get 1-2 range limit
max_distance /= 2;
TObj *tobj = dynamic_cast<TObj *>(this);
if (tobj && !tobj->canWear(ITEM_THROW))
max_distance /= 2;
// allow it to go 1 room, people get pissy otherwise
max_distance = max(max_distance, (unsigned int) 1);
#if RANGE_DEBUG
char buf[256];
sprintf(buf, "Ranged debug: max_distance: %d\n\racceleration: %6.2f, velocity: %6.2f\n\rhangtime: %6.2f, angle: %d", max_distance, acc, v0, tt, ang);
vlogf(LOG_BUG, buf);
#endif
ch->learnFromDoingUnusual(LEARN_UNUSUAL_NORM_LEARN, SKILL_RANGED_PROF, 20);
strcpy(local_vict, vict);
if(sstring(local_vict).isNumber() && (sscanf(local_vict, "%d", &iDist) == 1))
*local_vict = '\0';
else
iDist = min(50, (int) max_distance);
if (iDist < 0) {
ch->sendTo("You need to supply a positive (or 0) distance to throw.\n\r");
return FALSE;
}
if (tdir == 4)
max_distance /= 2; // you can only throw upwards half as far
if ((iDist > 50) || (max_distance < (unsigned int) iDist)) {
ch->sendTo("Much too far. Maybe in your dreams!\n\r");
ch->sendTo(fmt("You couldn't possibly throw it further than %d rooms.\n\r") % max_distance);
return FALSE;
}
count = 0;
if (*local_vict)
targ = get_char_vis_direction(ch, local_vict, tdir, iDist, TRUE, &count);
else
targ = NULL;
if (targ && ch->checkPeacefulVictim("A strange force prevents you from contemplating hurting your target.\n\r", targ))
return FALSE;
if (targ && ch->noHarmCheck(targ))
return FALSE;
// treat fliers as being 1 room further away
if (targ && targ->isFlying() && ((count+1) > max_distance)) {
act("Unfortunately, $N is flying and you can't quite reach that far.",
FALSE, ch, 0, targ, TO_CHAR);
return FALSE;
}
act("You throw $p!", FALSE, ch, this, 0, TO_CHAR);
act("$n throws $p!", TRUE, ch, this, 0, TO_ROOM);
tmp = ch->unequip(ch->getPrimaryHold());
if (!tmp) {
vlogf(LOG_BUG, "Bad unequip in throwThing (%s : %s)", getName(), ch->getName());
ch->sendTo("Something real bad happened. Talk to a god.\n\r");
return FALSE;
}
*ch->roomp += *tmp;
rc = throwThing(this, tdir, ch->in_room, &targ, iDist, max_distance,ch);
if (IS_SET_DELETE(rc, DELETE_ITEM)) {
return DELETE_THIS;
}
if (IS_SET_DELETE(rc, DELETE_VICT)) {
delete targ;
targ = NULL;
}
ch->addToWait(combatRound(2));
ch->addToMove(-2);
rc = checkSpec(NULL, CMD_OBJ_THROWN, NULL, NULL);
if (IS_SET_DELETE(rc, DELETE_THIS))
return DELETE_THIS;
return TRUE;
}
void TBeing::doThrow(const sstring &argument)
{
TThing *t;
sstring object, dir, vict;
int rc;
dirTypeT tdir;
if (checkPeaceful("You feel too peaceful to contemplate violence.\n\r"))
return;
if (getMove() <= 2) {
sendTo("You are too tired to throw anything!\n\r");
return;
}
vict="";
object=argument.word(0);
dir=argument.word(1);
vict=argument.word(2);
if (object.empty()) {
sendTo("Syntax: throw <object> [direction] [character | distance]\n\r");
return;
}
tdir = getDirFromChar(dir);
if (tdir == DIR_NONE) {
vict=dir;
tdir = dirTypeT(::number(MIN_DIR, MAX_DIR-1));
}
if (vict.empty()) {
if (fight())
vict=fight()->name;
else
vict="mama-o-Brutius";
}
if (!(t = equipment[getPrimaryHold()])) {
sendTo("You can only throw objects you are holding in your primary hand.\n\r");
return;
}
TObj * tobj = dynamic_cast<TObj *>(t);
if (tobj) {
if (tobj->isObjStat(ITEM_NEWBIE)) {
sendTo("That item might suck, but you can't just go throwing it around.\n\r");
return;
}
if (tobj->isObjStat(ITEM_NODROP)) {
sendTo("You can't throw a cursed item!\n\r");
return;
}
}
if (!isname(object, t->name)) {
sendTo("You can only throw objects you are holding in your primary hand.\n\r");
return;
}
rc = t->throwMe(this, tdir, vict.c_str());
if (IS_SET_DELETE(rc, DELETE_THIS)) {
delete t;
t = NULL;
}
return;
}
int get_range_actual_damage(TBeing *ch, TBeing *victim, TObj *o, int dam, spellNumT attacktype)
{
if (ch->damCheckDeny(victim, attacktype))
return 0;
dam = victim->skipImmortals(dam);
if (!ch->damDetailsOk(victim, dam, TRUE))
return 0;
dam = ch->damageTrivia(victim, o, dam, attacktype);
// adjust the damage based on their skill
if (dam) {
int q;
if (dynamic_cast<TArrow *>(o)) {
// shot objects are here
// ranged spec basically allows arrow to do extra damage...
q = 100;
q += (ch->getSkillValue(SKILL_RANGED_PROF)/2); // 50%-100% damage
q += (ch->getSkillValue(SKILL_RANGED_SPEC)/2); // 100%-150% damage
dam *= q;
dam /= 100;
} else {
// thrown objects are here
q = ch->getSkillValue(SKILL_RANGED_PROF);
dam *= q;
dam /= 100;
}
dam = max(dam,1);
}
return (dam);
}
void pissOff(TMonster *irritated, TBeing *reason)
{
affectedData af;
const int PISSED_MOB_PERSIST = 250; // make em damn persistant
if (!(irritated->canSee(reason, INFRA_YES)) || reason->isImmortal())
return;
if (irritated->getPosition() >= POSITION_SLEEPING) {
if (!irritated->isDumbAnimal()) {
switch (dice(1, 10)) {
case 1:
act("$n screams 'I must kill $N!", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 2:
act("$n says 'That's it, $N is toast.'", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 3:
act("$n growls '$N must die'", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 4:
act("$n begins to curse about $N.", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 5:
act("$n says 'Time to go killing.'", TRUE, irritated, 0, reason, TO_ROOM);
break;
default:
act("$n screams in rage!", TRUE, irritated, 0, reason, TO_ROOM);
break;
}
} else
irritated->aiGrowl(NULL);
SET_BIT(irritated->specials.act, ACT_HUNTING);
irritated->specials.hunting = reason;
irritated->hunt_dist = -500; // -500 means mobs will open doors!
irritated->persist = PISSED_MOB_PERSIST;
irritated->oldRoom = irritated->inRoom();
irritated->addHated(reason);
if (!irritated->affectedBySpell(SPELL_TRAIL_SEEK)) {
af.type = SPELL_TRAIL_SEEK; // make sure mob hunts global
af.duration = PISSED_MOB_PERSIST;
af.modifier = 0;
af.location = APPLY_NONE;
af.bitvector = 0;
irritated->affectTo(&af);
}
}
}
// ch is thrower of thing (sometimes NULL - falling objects)
// vict is potential victim
bool hitInnocent(const TBeing *ch, const TThing *thing, const TThing *vict)
{
// hit innocent due to misthrow
const TBeing * tbc = dynamic_cast<const TBeing *>(vict);
if (ch) {
if (ch->isImmortal())
return FALSE;
// presume anyone near thrower is safely out of the way
if (tbc && tbc->sameRoom(*ch))
return false;
// protect the mounts of group members too
if (tbc && tbc->rider) {
TBeing *temp = dynamic_cast<TBeing *>(tbc->horseMaster());
if (temp && temp->inGroup(*ch) && temp->sameRoom(*ch))
return false;
}
}
float num;
// size of target
num = vict->getHeight();
num *= vict->getWeight();
num /= 1000;
// num should be on order of 15 - 70
num += 1 + thing->getVolume()/1000;
if (ch) {
num -= ch->plotStat(STAT_CURRENT, STAT_AGI, -10, 10, 0);
}
if (tbc) {
num -= tbc->plotStat(STAT_CURRENT, STAT_PER, -5, 5, 0);
num -= tbc->plotStat(STAT_CURRENT, STAT_SPE, -5, 5, 0);
}
return (::number(20, 100) < num);
}
// returns DELETE_ITEM if *thing should be nuked
// returns DELETE_VICT if *targ should go poof (|| able)
// return TRUE if it hits something (stops moving), otherwise false
// cdist = current dist traveled
// mdist = max range item can go
int catch_or_smack(TRoom *rp, TBeing **targ, TThing *thing, TBeing *ch, int cdist, int mdist)
{
return thing->catchSmack(ch, targ, rp, cdist, mdist);
}
int TThing::catchSmack(TBeing *ch, TBeing **targ, TRoom *rp, int cdist, int mdist)
{
TThing *c, *c_next;
int d = 0;
bool true_targ;
int i;
int resCode = 0;
int damtype;
int range;
damtype = getWtype();
for (c = rp->getStuff(); c; c = c_next) {
c_next = c->nextThing;
TBeing *tbt = dynamic_cast<TBeing *>(c);
if (!tbt || (tbt == ch))
continue;
// range is sort of a modified cdist
if (tbt->isFlying())
range = cdist + 1;
else
range = cdist;
// anyone we want to hit here? (including innocents)
// the ch->isImmortal() checks prevent gods from hitting innocents
if ((true_targ = (tbt == *targ)) ||
hitInnocent(ch, this, tbt)) {
// if we hit an innocent, treat range as being greater so that damage
// is less than if it was intentional
if (!true_targ && range != mdist)
range++;
if ((::number(1, 25) < tbt->plotStat(STAT_CURRENT, STAT_SPE, 3, 18, 13)) &&
tbt->hasHands() && !tbt->bothHandsHurt() &&
tbt->awake() && tbt->canGet(this, SILENT_YES)) {
resCode = TRUE;
act("$n catches $p.", FALSE, tbt, this, NULL, TO_ROOM);
if (!ch->sameRoom(*tbt))
act("In the distance, $N catches your $o.",TRUE,ch,this,tbt,TO_CHAR);
if (!tbt->heldInPrimHand()) {
act("You catch $p.",
FALSE,tbt,this,0,TO_CHAR);
--(*this);
tbt->equipChar(this, tbt->getPrimaryHold());
} else if (!tbt->heldInSecHand()) {
act("You catch $p.",
FALSE,tbt,this,0,TO_CHAR);
--(*this);
tbt->equipChar(this, tbt->getSecondaryHold());
} else {
act("You catch $p, and add it to your inventory.",
FALSE,tbt,this,0,TO_CHAR);
--(*this);
*tbt += *this;
}
if (!tbt->isPc())
pissOff(dynamic_cast<TMonster *>(tbt), ch);
if (cdist == 0)
ch->setCharFighting(tbt, 0);
return resCode;
} else if (!ch->isImmortal() &&
(!(i = ch->specialAttack(tbt, SKILL_RANGED_PROF)) ||
i == GUARANTEED_FAILURE)) {
act("$n dodges out of the way of $p.", FALSE, tbt, this, NULL, TO_ROOM);
tbt->sendTo("You dodge out of its way.\n\r");
if (!ch->sameRoom(*tbt))
act("In the distance, $N dodges out of the way of $p.",
TRUE,ch,this,tbt,TO_CHAR);
resCode = FALSE;
if (!tbt->isPc())
pissOff(dynamic_cast<TMonster *>(tbt), ch);
if (cdist == 0)
ch->setCharFighting(tbt, 0);
return resCode;
} else {
// smacked by non-weapon/arrow
if (true_targ)
act("$n is smacked by $p!", FALSE, tbt, this, NULL, TO_ROOM);
else
act("$n is accidentally smacked by $p!", FALSE, tbt, this, NULL, TO_ROOM);
act("You are unable to dodge being hit by $p!",
FALSE, tbt, this, NULL, TO_CHAR);
if (!ch->sameRoom(*tbt))
act("In the distance, $N is hit by $p.",TRUE,ch,this,tbt,TO_CHAR);
resCode = TRUE;
d = min(max(0, (int) (getWeight() - 5)), 10);
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) dam ping 1: %d", d);
#endif
// don't do this or we wind up with acorns killing people
// d *= mdist - range + 1; // modify for point blank range - bat
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) dam ping 3: %d", d);
#endif
TObj *tobj = dynamic_cast<TObj *>(this);
if (tobj) {
d = get_range_actual_damage(ch, tbt, tobj, d, TYPE_HIT);
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) dam ping 4: %d", d);
#endif
if (::number(1, d) <= tobj->getStructPoints() &&
tbt->roomp && !tbt->roomp->isRoomFlag(ROOM_ARENA)) {
tobj->addToStructPoints(-1);
if (tobj->getStructPoints() <= 0) {
if (!ch->sameRoom(*tbt))
act("In the distance, $p is destroyed.",TRUE,ch,tobj,0,TO_CHAR);
tobj->makeScraps();
ADD_DELETE(resCode, DELETE_ITEM);
}
}
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) %s damaging %s with %s for %d dam",
ch->getName(), tbt->getName(), tobj->getName(), d);
#endif
if (ch->reconcileDamage(tbt, d, getWtype()) == -1) {
if (true_targ) {
ADD_DELETE(resCode, DELETE_VICT);
return resCode;
}
delete tbt;
tbt = NULL;
return resCode;
}
}
if (tbt && !tbt->isPc())
pissOff(dynamic_cast<TMonster *>(tbt), ch);
if (cdist == 0)
ch->setCharFighting(tbt, 0);
if (true_targ)
*targ = tbt;
return resCode;
}
}
}
return FALSE;
}
int hit_obstacle_in_room(TRoom *rp, TThing *thing, TBeing *ch)
{
TThing *t;
for (t = rp->getStuff(); t; t = t->nextThing) {
TObj *obj = dynamic_cast<TObj *>(t);
if (obj) {
if ((obj != thing) && (!number(0, 4)) && (obj->getVolume() > 10000) &&
(obj->getVolume() > ((dice(1, 1000) * 1000)) - thing->getVolume())) {
act("$n smacks into $N, and falls to the $g.",
TRUE, thing, 0, obj, TO_ROOM);
act("$p smacked into $N.", FALSE, ch, thing, obj, TO_CHAR);
if (thing->spec) thing->checkSpec(NULL, CMD_ARROW_HIT_OBJ, "", obj);
return TRUE;
}
}
}
return FALSE;
}
static void barrier(TRoom *rp, dirTypeT dir, TThing *t)
{
char buf[256];
switch (rp->getSectorType()) {
case SECT_TROPICAL_BUILDING:
case SECT_TEMPERATE_BUILDING:
case SECT_ARCTIC_BUILDING:
case SECT_TROPICAL_CAVE:
case SECT_TEMPERATE_CAVE:
case SECT_ARCTIC_CAVE:
if (dir == 5)
sprintf(buf, "$n glances off the $g at a strange angle and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n bounces off the ceiling and drops to the $g.");
else
sprintf(buf, "$n bounces off a wall and drops to the $g.");
break;
case SECT_ARCTIC_CITY:
case SECT_TEMPERATE_CITY:
case SECT_TROPICAL_CITY:
if (dir == 5)
sprintf(buf, "$n glances off the $g at a strange angle and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n sails briefly into the air above before falling to the $g.");
else
sprintf(buf, "$n bounces off a wall and drops to the $g.");
break;
case SECT_JUNGLE:
case SECT_RAINFOREST:
case SECT_TEMPERATE_FOREST:
case SECT_ARCTIC_FOREST:
if (dir == 5)
sprintf(buf, "$n glances off a stump and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n bounces off a branch above before falling to the $g.");
else
sprintf(buf, "$n flies through the air a ways before hitting a tree.");
break;
case SECT_ARCTIC_RIVER_SURFACE:
case SECT_ICEFLOW:
case SECT_TEMPERATE_OCEAN:
case SECT_TEMPERATE_RIVER_SURFACE:
case SECT_TROPICAL_RIVER_SURFACE:
case SECT_TROPICAL_OCEAN:
if (dir == 5)
sprintf(buf, "$n splashes into the water.");
else if (dir == 4)
sprintf(buf, "$n flies into the air, and falls into the water below.");
else
sprintf(buf, "$n flies through the air a ways before splashing into the water.");
break;
case SECT_TROPICAL_UNDERWATER:
case SECT_TEMPERATE_UNDERWATER:
sprintf(buf, "$n is slowed to a halt by the water.");
break;
case SECT_TROPICAL_ATMOSPHERE:
case SECT_TEMPERATE_ATMOSPHERE:
case SECT_ARCTIC_ATMOSPHERE:
sprintf(buf, "$n loses momentum and begins to fall!");
break;
case SECT_DESERT:
case SECT_TROPICAL_BEACH:
case SECT_TEMPERATE_BEACH:
case SECT_COLD_BEACH:
case SECT_ARCTIC_MARSH:
case SECT_TEMPERATE_SWAMP:
case SECT_TROPICAL_SWAMP:
if (dir == 5)
sprintf(buf, "$n slams into the $g and comes to a stop.");
else
sprintf(buf, "$n flies a short distance before crashing into the $g.");
break;
case SECT_SOLID_ICE:
sprintf(buf, "$n slams into a chunk of ice and gets stuck.");
break;
case SECT_SOLID_ROCK:
sprintf(buf, "$n glances off a rock outcropping and stops flying.");
break;
case SECT_ASTRAL_ETHREAL:
sprintf(buf, "A weird distortion in the matrix stops $n from flying.");
break;
case SECT_FIRE:
case SECT_VOLCANO_LAVA:
if (dir == 5)
sprintf(buf, "$n disappears as it hits the flaming molten surface below.");
else
sprintf(buf, "$n goes a short ways before falling into the flaming surface below.");
break;
case SECT_SUBARCTIC:
case SECT_ARCTIC_WASTE:
case SECT_ARCTIC_ROAD:
case SECT_TUNDRA:
case SECT_ARCTIC_MOUNTAINS:
case SECT_PLAINS:
case SECT_TEMPERATE_ROAD:
case SECT_GRASSLANDS:
case SECT_TEMPERATE_HILLS:
case SECT_TEMPERATE_MOUNTAINS:
case SECT_SAVANNAH:
case SECT_VELDT:
case SECT_TROPICAL_ROAD:
case SECT_TROPICAL_HILLS:
case SECT_TROPICAL_MOUNTAINS:
default:
if (dir == 5)
sprintf(buf, "$n glances off the $g at a strange angle and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n sails briefly into the air above before falling to the $g.");
else
sprintf(buf, "$n flies through the air a ways before dropping to the $g.");
}
act(buf, TRUE, t, 0, 0, TO_ROOM);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
}
// max_dist is the maximum distance that "o" can be thrown.
// iDist is how far user wants item to go
// distance is actual amount flown
// return DELETE_ITEM if t should go poof
// returns DELETE_VICT if *targ should die (|| able)
int throwThing(TThing *t, dirTypeT dir, int from, TBeing **targ, int dist, int max_dist, TBeing *ch)
{
char capbuf[256];
TRoom *rp, *newrp;
int iDist = 0;
int rc;
// send the thing up to "dist" rooms away, checking for our target
while ((rp = real_roomp(from))) {
if (iDist) {
sprintf(capbuf, "$n %s into the room %s.", (dir == 5 ? "drops" : "flies"), directions[dir][1]);
act(capbuf, TRUE, t, 0, 0, TO_ROOM);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_INTO_ROOM, "", NULL);
} else {
if (t->spec) t->checkSpec(NULL, CMD_ARROW_SHOT, "", NULL);
}
if (hit_obstacle_in_room(rp, t, ch))
return FALSE;
// max_dist here is used to modify damage based on how far away they are.
// use the absolute max it can go (max_dist) for this calculation
rc = catch_or_smack(rp, targ, t, ch, iDist, max_dist);
if (IS_SET_DELETE(rc, DELETE_ITEM) || IS_SET_DELETE(rc, DELETE_VICT))
return rc;
else if (rc)
return FALSE;
// users specified to fly "dist" rooms, so probably only provided
// momentum for that far. Use dist in this check, rather than max_dist
iDist++;
if (iDist > dist || iDist > max_dist) {
act("$n drops to the $g.", TRUE, t, 0, 0, TO_ROOM);
if (dir != DIR_DOWN)
act("$p ran out of momentum and fell.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
} else if (!clearpath(from, dir) || rp->isUnderwaterSector()) {
barrier(rp, dir,t);
act("$p hit an obstacle and dropped to the $g.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
}
// No need to check for a NULL newrp, clearpath() does that. - Russ
newrp = real_roomp(rp->dir_option[dir]->to_room);
if (newrp->isRoomFlag(ROOM_PEACEFUL) || newrp->isRoomFlag(ROOM_NO_MOB)) {
act("Strangely, $n hits a magical barrier and falls to the $g.",
FALSE, t, 0, 0, TO_ROOM);
act("$p hit a magic barrier and dropped to the $g.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
}
if (newrp->isRoomFlag(ROOM_NO_HEAL)) {
act("Strangely, $n hits a magical barrier and falls to the $g.",
FALSE, t, 0, 0, TO_ROOM);
act("$p hit a magic barrier and dropped to the $g.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
}
sprintf(capbuf, "$n %s %s out of the room.", (dir == 5 ? "drops" : "flies"), directions[dir][0]);
act(capbuf, TRUE, t, 0, 0, TO_ROOM);
--(*t);
from = rp->dir_option[dir]->to_room;
*(real_roomp(from)) += *t;
}
if (!rp) {
vlogf(LOG_BUG, "%s thrown into non-existant room #%d", capbuf, from);
--(*t);
thing_to_room(t, ROOM_VOID);
return FALSE;
}
return FALSE;
}
// ch attempts to see targ by looking linearly in all cardinal directions
// returns the direction targ was spotted in, or -1 (failure)
// range and dir are also passed as formal vars
dirTypeT can_see_linear(const TBeing *ch, const TBeing *targ, int *rng, dirTypeT *dr)
{
int rm, max_range = 15, range = 0;
int height = 0;
// add bonus from race
max_range += ch->getMyRace()->getLOS();
max_range += (ch->visionBonus + 1)/2;
switch (ch->getPosition()) {
case POSITION_MOUNTED:
height = 4*dynamic_cast<TBeing *>(ch->riding)->getHeight()/5 + 2*ch->getHeight()/3;
break;
case POSITION_STANDING:
case POSITION_FIGHTING:
height = ch->getHeight();
break;
case POSITION_SITTING:
height = ch->getHeight()/3;
break;
case POSITION_CRAWLING:
height = ch->getHeight()/4;
break;
case POSITION_RESTING:
case POSITION_SLEEPING:
default:
height = ch->getHeight()/6;
break;
}
if (height > 80)
max_range += 2;
else if (height > 75)
max_range += 1;
else if (height < 60)
max_range -= 2;
else if (height < 65)
max_range -= 1;
if ((ch->age()->year - ch->getBaseAge() + 17) > 80)
max_range -= 3;
else if ((ch->age()->year - ch->getBaseAge() + 17) > 60)
max_range -= 2;
else if ((ch->age()->year - ch->getBaseAge() + 17) > 40)
max_range -= 1;
else if ((ch->age()->year - ch->getBaseAge() + 17) < 20)
max_range += 1;
if ((ch->roomp->getWeather() == WEATHER_RAINY) ||
(ch->roomp->getWeather() == WEATHER_LIGHTNING))
max_range /= 2;
else if (ch->roomp->getWeather() == WEATHER_SNOWY)
max_range /= 4;
dirTypeT i;
for (i = MIN_DIR; i < MAX_DIR; i++) {
rm = ch->in_room;
range = 0;
while (range < max_range) {
range++;
max_range -= TerrainInfo[real_roomp(rm)->getSectorType()]->thickness;
if (clearpath(rm, i)) {
rm = real_roomp(rm)->dir_option[i]->to_room;
const TThing *t;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
if ((t == targ) && ch->canSee(t)) {
*rng = range;
*dr = i;
return i;
}
}
}
}
}
return DIR_NONE;
}
TBeing *get_char_linear(const TBeing *ch, char *arg, int *rf, dirTypeT *df)
{
int rm, max_range = 15, range = 0, n, n_sofar = 0;
TThing *t;
char *tmp, tmpname[256];
if ((ch->getRace() == RACE_ELVEN) || (ch->getRace() == RACE_DROW))
max_range += 5;
max_range += (ch->visionBonus + 1)/2;
if ((ch->roomp->getWeather() == WEATHER_RAINY) ||
(ch->roomp->getWeather() == WEATHER_LIGHTNING))
max_range /= 2;
else if (ch->roomp->getWeather() == WEATHER_SNOWY)
max_range /= 4;
strcpy(tmpname, arg);
tmp = tmpname;
if (!(n = get_number(&tmp)))
return NULL;
// This routine counts folks in your room
rm = ch->in_room;
dirTypeT i = DIR_NONE;
range = 0;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
TBeing *tbt = dynamic_cast<TBeing *>(t);
if (tbt && (isname(tmp, tbt->name)) && ch->canSee(tbt)) {
n_sofar++;
if (n_sofar == n) {
*rf = range;
*df = DIR_NONE;
return tbt;
}
}
}
for (i = MIN_DIR; i < MAX_DIR; i++) {
rm = ch->in_room;
range = 0;
while (range < max_range) {
range++;
max_range -= TerrainInfo[real_roomp(rm)->getSectorType()]->thickness;
if (clearpath(rm, i)) {
rm = real_roomp(rm)->dir_option[i]->to_room;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
TBeing *tbt = dynamic_cast<TBeing *>(t);
if (tbt && (isname(tmp, tbt->getName())) && ch->canSee(tbt)) {
n_sofar++;
if (n_sofar == n) {
*rf = range;
*df = i;
return tbt;
}
}
}
} else
range = max_range + 1;
}
}
return NULL;
}
int clearpath(int room, dirTypeT dir)
{
TRoom *rp;
rp = real_roomp(room);
if (!rp || !rp->dir_option[dir])
return FALSE;
if (rp->dir_option[dir]->to_room < 1)
return FALSE;
if (!real_roomp(rp->dir_option[dir]->to_room)) {
vlogf(LOG_BUG, "Range function done in room with bad exit. (%d) Dir:[%d]", room, dir);
return FALSE;
}
if (IS_SET(rp->dir_option[dir]->condition, EX_CLOSED))
return FALSE;
return (real_roomp(room)->dir_option[dir]->to_room);
}
void TBeing::doScan(const char *argument)
{
const char *rng_desc[] =
{
"right here", // 0
"immediately",
"nearby",
"a short ways",
"not too far",
"a ways", // 5 room
"quite a ways",
"way off",
"way off",
"far",
"far", // 10 rooms
"way way off",
"way way off",
"real far",
"real far",
"very far", // 15 rooms
"very far",
"extremely far",
"extremely far",
"on the horizon",
"on the horizon", // 20 rooms
"on the horizon",
"on the horizon",
"on the horizon",
"on the horizon"
};
char buf[256], buf2[256];
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
int max_range = 15, range, new_rm, rm, nfnd;
int hindered;
bool found = FALSE;
TThing *t;
bool all = FALSE;
argument_split_2(argument, arg1, arg2);
float swt;
dirTypeT sd = getDirFromChar(arg1);
dirTypeT smin, smax;
if (sd == DIR_NONE) {
smin = MIN_DIR;
smax = dirTypeT(MAX_DIR-1);
swt = 1.5;
sprintf(buf, "$n peers intently all around.");
sprintf(buf2, "You peer intently all around, and see :\n\r");
all = TRUE;
} else {
smin = sd;
smax = sd;
swt = 0.5;
sprintf(buf, "$n peers intently %s.", dirs_to_blank[sd]);
sprintf(buf2, "You peer intently %s, and see :\n\r", dirs_to_blank[sd]);
}
if (getMove() < (all ? 10 : 2)) {
sendTo("You are simply too exhausted!\n\r");
return;
}
act(buf, TRUE, this, 0, 0, TO_ROOM);
sendTo(buf2);
if (!inLethargica())
addToMove(all ? -10 : -2);
if (isAffected(AFF_BLIND) && !isAffected(AFF_TRUE_SIGHT)) {
sendTo("Nothing, you are blind.\n\r");
return;
}
nfnd = 0;
// Check in room first
if (all) {
// for specific directions, skip room so it doesn't count toward "nfnd"
for (t = roomp->getStuff(); t; t = t->nextThing) {
if (!dynamic_cast<TBeing *>(t))
continue;
if (t == this)
continue;
if (canSee(t)) {
sendTo(COLOR_MOBS, fmt("%30s : right here\n\r") % t->getNameNOC(this));
found = TRUE;
} else if (canSee(t, INFRA_YES)) {
sendTo(COLOR_MOBS, fmt("%30s : right here\n\r") % "A blob of heat");
found = TRUE;
}
}
}
max_range -= TerrainInfo[roomp->getSectorType()]->thickness;
max_range += (visionBonus / 10);
// Let weather conditions play a part in range - Russ 10/14/98
// silly immortal check, but imms gripe about it
if (!isImmortal()) {
if (roomp->getWeather() == WEATHER_SNOWY) {
max_range -= 3;
sendTo(COLOR_BASIC, "The <W>SNOW<1> greatly decreases your view!\n\r");
} else if (roomp->getWeather() == WEATHER_RAINY) {
max_range -= 2;
sendTo(COLOR_BASIC, "The <B>RAIN<1> decreases your view!\n\r");
} else if (roomp->getWeather() == WEATHER_CLOUDY) {
max_range -= 1;
sendTo(COLOR_BASIC, "The <k>FOG<1> slightly decreases your view!\n\r");
//sendTo(COLOR_BASIC, "The <k>CLOUDS<1> slightly decrease your view!\n\r");
} else if (roomp->getWeather() == WEATHER_CLOUDLESS) {
max_range += 1;
sendTo(COLOR_BASIC, "The <c>clear skies<1> enhance your view!\n\r");
}
}
dirTypeT i;
for (i = smin; i <= smax; i++) {
nfnd = 0;
hindered = FALSE;
rm = in_room;
range = 0;
while ((range < max_range) && !hindered) {
range++;
if (clearpath(rm, i)) {
new_rm = real_roomp(rm)->dir_option[i]->to_room;
if (new_rm == rm)
break;
else
rm = new_rm;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
TBeing *tbt = dynamic_cast<TBeing *>(t);
if (!tbt)
continue;
if (can_see_char_other_room(this, tbt, real_roomp(rm))) {
sendTo(COLOR_MOBS, fmt("%30s : %s %s\n\r") % tbt->getNameNOC(this) % rng_desc[range] % dirs_to_blank[i]);
nfnd++;
found = TRUE;
if (nfnd > (5 + visionBonus / 3)) {
sendTo(fmt("The crowd hinders you from seeing any further %s.\n\r") % dirs_to_blank[i]);
hindered = TRUE;
break;
}
} else if (canSee(tbt, INFRA_YES)) {
sendTo(COLOR_MOBS, fmt("%30s : %s %s\n\r") % "A blob of heat" % rng_desc[range] % dirs_to_blank[i]);
nfnd++;
found = TRUE;
if (nfnd > (5 + visionBonus / 3)) {
sendTo(fmt("The crowd hinders you from seeing any further %s.\n\r") % dirs_to_blank[i]);
hindered = TRUE;
break;
}
}
}
} else
range = max_range + 1;
}
}
if (!found)
sendTo("Nothing.\n\r");
addToWait(combatRound(swt));
}
// returns DELETE_THIS
int TBeing::stickIn(TThing *o, wearSlotT pos, silentTypeT silent)
{
int rc;
char buf[80];
if ((pos == HOLD_RIGHT)) {
pos = WEAR_HAND_R;
} else if (pos == HOLD_LEFT) {
pos = WEAR_HAND_L;
}
mud_assert(!o->equippedBy && !o->parent && (o->in_room == -1),
"stickIn: item had owner at invocation");
mud_assert(pos >= MIN_WEAR && pos < MAX_WEAR,
"Bad slot in stickIn, %s %d", getName(), pos);
mud_assert(slotChance(pos),
"No slot chance in stickIn, %s %d", getName(), pos);
mud_assert(getStuckIn(pos) == NULL,
"stickIn: bodyPart had item stuckIn already");
mud_assert(roomp != NULL,
"stickIn: ch with no roomp");
setStuckIn(pos, o);
o->eq_stuck = pos;
o->stuckIn = this;
if (!silent) {
sprintf(buf, "$p sticks in $n's %s!", describeBodySlot(pos).c_str());
act(buf, FALSE, this, o, 0, TO_ROOM);
sprintf(buf, "$p sticks in your %s!", describeBodySlot(pos).c_str());
act(buf, FALSE, this, o, 0, TO_CHAR);
}
TObj *obj = dynamic_cast<TObj *>(o);
if (obj && obj->spec) {
rc = ((objSpecials[GET_OBJ_SPE_INDEX(obj->spec)].proc)
(this, CMD_OBJ_STUCK_IN, "", obj, NULL));
if (IS_SET_DELETE(rc, DELETE_THIS))
return DELETE_THIS;
}
return TRUE;
}
TThing *has_range_object(TBeing *ch, int *pos)
{
TThing *hucked;
TObj *tobj;
if (!ch->equipment[HOLD_RIGHT] && !ch->equipment[HOLD_LEFT] && !ch->getStuff())
return NULL;
// Go thru possible places for throwing objects.
if ((hucked = ch->equipment[HOLD_RIGHT])) {
tobj = dynamic_cast<TObj *>(hucked);
if (tobj && tobj->canWear(ITEM_THROW)) {
*pos = HOLD_RIGHT;
return (tobj);
}
} else if ((hucked = ch->equipment[HOLD_LEFT])) {
tobj = dynamic_cast<TObj *>(hucked);
if (tobj && tobj->canWear(ITEM_THROW)) {
*pos = HOLD_LEFT;
return (tobj);
}
} else {
for (TThing *t = ch->getStuff(); t; t = t->nextThing) {
tobj = dynamic_cast<TObj *>(t);
if (tobj && tobj->canWear(ITEM_THROW)) {
*pos = -1;
return tobj;
}
}
}
return NULL;
}
// ----------------------------------------------
int go_ok(roomDirData *exitp)
{
return (!IS_SET(exitp->condition, EX_CLOSED | EX_LOCKED | EX_SECRET) &&
(exitp->to_room != ROOM_NOWHERE));
}
int go_ok_smarter(roomDirData *exitp)
{
return (!IS_SET(exitp->condition, EX_LOCKED | EX_SECRET) &&
(exitp->to_room != ROOM_NOWHERE));
}
#if 0
static void donothing(void *);
static void donothing(void *)
{
return;
}
#endif
class pathData {
public:
dirTypeT direct;
int source;
bool checked;
pathData() : direct(DIR_NONE), source(0), checked(false) {}
};
// returns DIR_NONE1 indicating a problem or can't find a path
// returns 0-9 indicating a direction to travel
// returns 10+ indicating a portal to enter (10 = first in room, 11 = 2nd,...)
dirTypeT find_path(int room, int (*pred) (int, void *), void *data, int depth, bool in_zone, int *answer, bool use_portals)
{
// just to be dumb, check my own room first
if ((pred) (room, data)) {
if (answer)
*answer = room;
return DIR_NONE;
}
bool thru_doors;
if (depth < 0) {
thru_doors = true;
depth = -depth;
} else
thru_doors = false;
// create this room as a starting point
pathData *pd = new pathData();
pd->direct = DIR_NONE;
pd->source = -1;
pd->checked = false;
map<int, pathData *>path_map;
path_map[room] = pd;
for(;;) {
map<int, pathData *>::const_iterator CI;
map<int, pathData *>next_map;
if (path_map.size() > (unsigned int) depth) {
if (answer)
*answer = path_map.size();
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI) {
pd = CI->second;
delete pd;
}
for (CI = next_map.begin(); CI != next_map.end(); ++CI) {
pd = CI->second;
delete pd;
}
return DIR_NONE;
}
for (CI = path_map.begin(); CI != path_map.end(); ++CI) {
// no need to do things twice
pd = CI->second;
if (pd->checked)
continue;
dirTypeT dir;
TRoom *rp = real_roomp(CI->first);
if (!rp) {
vlogf(LOG_BUG, "Problem iterating path map.");
continue;
}
if(!use_portals){
for (dir = MIN_DIR; dir < MAX_DIR; dir++) {
roomDirData *exitp = rp->dir_option[dir];
TRoom *hp = NULL;
if (exitp &&
(hp = real_roomp(exitp->to_room)) &&
(thru_doors ? go_ok_smarter(exitp) : go_ok(exitp))) {
// check in_zone criteria
if (in_zone && (hp->getZoneNum() != rp->getZoneNum())) {
continue;
}
// do we have this room already?
map<int, pathData *>::const_iterator CT;
CT = path_map.find(exitp->to_room);
if (CT != path_map.end())
continue;
CT = next_map.find(exitp->to_room);
if (CT != next_map.end())
continue;
// is this our target?
if ((pred) (exitp->to_room, data)) {
// found our target, walk our list backwards
if (answer)
*answer = exitp->to_room;
pd = CI->second;
for (;;) {
if (pd->source == -1) {
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI) {
pathData *tpd = CI->second;
delete tpd;
}
for (CI = next_map.begin(); CI != next_map.end(); ++CI) {
pathData *tpd = CI->second;
delete tpd;
}
return dir;
}
dir = pd->direct;
pd = path_map[pd->source];
}
}
// it's not our target, and we don't have this room yet
pd = new pathData();
pd->source = CI->first;
pd->direct = dir;
pd->checked = false;
next_map[exitp->to_room] = pd;
}
}
}
// check for portals that might lead to target
// return 10 if its the 1st portal in the room, 11 for 2nd, etc
// 0-9 are obviously real exits (see above)
if (thru_doors || use_portals) {
dir = dirTypeT(MAX_DIR-1);
TThing *t;
for (t = rp->getStuff(); t; t = t->nextThing) {
TPortal *tp = dynamic_cast<TPortal *>(t);
if (!tp)
continue;
dir++; // increment portal
if (tp->isPortalFlag(EX_LOCKED | EX_CLOSED))
continue;
int tmp_room = tp->getTarget(); // next room
TRoom *hp = real_roomp(tmp_room);
if (!hp) {
continue;
}
// check in_zone criteria
if (in_zone && (hp->getZoneNum() != rp->getZoneNum())) {
continue;
}
// do we have this room already?
map<int, pathData *>::const_iterator CT;
CT = path_map.find(tmp_room);
if (CT != path_map.end())
continue;
CT = next_map.find(tmp_room);
if (CT != next_map.end())
continue;
// is this our target?
if ((pred) (tmp_room, data)) {
// found our target, walk our list backwards
if (answer)
*answer = tmp_room;
pd = CI->second;
for (;;) {
if (pd->source == -1) {
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI)
delete CI->second;
for (CI = next_map.begin(); CI != next_map.end(); ++CI)
delete CI->second;
return dir;
}
dir = pd->direct;
pd = path_map[pd->source];
}
}
// it's not our target, and we don't have this room yet
pd = new pathData();
pd->source = CI->first;
pd->direct = dir;
pd->checked = false;
next_map[tmp_room] = pd;
} // stuff in room
}
// end portal check
// we've checked all dirs for this room, so mark it checked
pd = CI->second;
pd->checked = true;
}
// if we failed to find any new rooms, abort, or be in an endless loop
if (next_map.size() == 0) {
if (answer)
*answer = ROOM_NOWHERE;
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI)
delete CI->second;
for (CI = next_map.begin(); CI != next_map.end(); ++CI)
delete CI->second;
return DIR_NONE;
}
// we've looped over the entire map list, so move the next_map values in
for (CI = next_map.begin(); CI != next_map.end(); ++CI) {
path_map[CI->first] = CI->second;
}
next_map.clear();
}
}
dirTypeT choose_exit_global(int in_room, int tgt_room, int depth)
{
return find_path(in_room, is_target_room_p, (void *) tgt_room, depth, 0);
}
dirTypeT choose_exit_in_zone(int in_room, int tgt_room, int depth)
{
return find_path(in_room, is_target_room_p, (void *) tgt_room, depth, 1);
}
int TBeing::doShoot(const char *arg)
{
char arg1[128], arg2[128];
TBeing *targ = NULL;
int rc, iDist;
dirTypeT dir;
TThing *t;
unsigned int count = 0;
// Prevent: order elemental shoot <blah>
// for Free xp.
if ((!desc || (!isPc() && !orig)) && !(spec)) //added spec for the BM archers.. hopefully wont cause problems - Dash
return FALSE;
rc = sscanf(arg, "%s %s %d", arg2, arg1, &iDist);
if (rc < 3)
iDist = 99;
if (rc < 2)
*arg1='\0';
if (rc < 1 || rc > 3) {
sendTo("Syntax : shoot <direction> <creature> <max-distance>\n\r");
return FALSE;
}
dir = getDirFromChar(arg2);
if (dir == DIR_NONE) {
strcpy(arg1, arg2);
dir = dirTypeT(::number(MIN_DIR, MAX_DIR-1));
}
if (checkPeaceful("You feel much too peaceful to contemplate violence.\n\r"))
return FALSE;
if (!(t = equipment[getPrimaryHold()])) {
sendTo("You are not holding a bow to shoot!\n\r");
return FALSE;
}
if (getSkillValue(SKILL_RANGED_PROF) <= 0 && !dynamic_cast<TGun *>(t)) {
sendTo("You almost shoot yourself in the foot!\n\r");
sendTo("You realize you don't have any clue what you're doing...get some training.\n\r");
return FALSE;
}
if (arg1 && *arg1 &&
!(targ = get_char_vis_direction(this, arg1, dir, iDist, TRUE, &count))) {
sendTo("No creature with that name in that room.\n\r");
sendTo("Syntax : shoot <direction> <creature> <max-distance>\n\r");
return FALSE;
}
rc = t->shootMeBow(this, targ, count, dir, iDist);
if (IS_SET_DELETE(rc, DELETE_THIS)) {
delete t;
t = NULL;
}
if (IS_SET_DELETE(rc, DELETE_VICT)) {
return DELETE_THIS;
}
// this is mainly for dual wielding guns, bows should be 2-handed
if((t = equipment[getSecondaryHold()]) &&
dynamic_cast<TObj *>(t) && !dynamic_cast<TObj *>(t)->usedAsPaired()){
rc = t->shootMeBow(this, targ, count, dir, iDist);
if (IS_SET_DELETE(rc, DELETE_THIS)) {
delete t;
t = NULL;
}
if (IS_SET_DELETE(rc, DELETE_VICT)) {
return DELETE_THIS;
}
}
return FALSE;
}
// DELETE_THIS, DELETE_VICT(ch)
int TThing::shootMeBow(TBeing *ch, TBeing *, unsigned int, dirTypeT, int)
{
act("$p isn't a bow!", FALSE, ch, this, 0, TO_CHAR);
return FALSE;
}
int TBeing::unloadBow(const char *arg)
{
TObj *arrow;
TBow *bow = NULL;
TThing *t;
if (!(t = equipment[getPrimaryHold()]) ||
!(bow = dynamic_cast<TBow *>(t)) ||
!bow->getStuff() || !dynamic_cast<TArrow *>(bow->getStuff()))
return FALSE;
arrow = dynamic_cast<TObj *>(bow->getStuff());
--(*arrow);
sendTo("You uncock your bow and take out its arrow!\n\r");
act("$n uncocks $s bow and takes out its arrow!",
TRUE, this, NULL, NULL, TO_ROOM);
*this += *(unequip(getPrimaryHold()));
*this += *arrow;
return TRUE;
}
TThing * TBeing::findArrow(const char *buf, silentTypeT silent) const
{
TThing *arrow;
TQuiver *tQuiver;
int curPos;
TThing *tThing;
arrow = searchLinkedListVis(this, buf, getStuff());
if (!arrow) {
for (curPos = MIN_WEAR; curPos < MAX_WEAR; curPos++) {
if ((tQuiver = dynamic_cast<TQuiver *>(equipment[curPos])) &&
!tQuiver->isClosed()) {
if ((arrow = searchLinkedListVis(this, buf, tQuiver->getStuff()))) {
if (!silent) {
act("You pull $p from $N.",
TRUE, this, arrow, tQuiver, TO_CHAR);
act("$n pulls $p from $N.",
TRUE, this, arrow, tQuiver, TO_ROOM);
}
return arrow;
}
}
}
for (tThing = getStuff(); tThing; tThing = tThing->nextThing) {
if (!(tQuiver = dynamic_cast<TQuiver *>(tThing)) ||
tQuiver->isClosed())
continue;
if (!(arrow = searchLinkedListVis(this, buf, tThing->getStuff())))
continue;
if (!silent) {
act("You pull $p from $N.",
TRUE, this, arrow, tQuiver, TO_CHAR);
}
return arrow;
}
return NULL;
}
return arrow;
}
void TBeing::doBload(const char *arg)
{
char arg1[128],
arg2[128];
TThing *bow;
TThing *arrow;
if (sscanf(arg, "%s %s", arg1, arg2) != 2) {
sendTo("Syntax : bload <bow> <arrow>\n\r");
return;
}
if (heldInPrimHand()) {
if (!isname(arg1, heldInPrimHand()->name)) {
sendTo(COLOR_OBJECTS, fmt("You would have a hard time firing your %s, while holding %s.\n\r") % arg1 % sstring(heldInPrimHand()->getName()).uncap());
return;
} else {
TThing *tObj = heldInPrimHand();
*this += *(unequip(getPrimaryHold()));
//--(*tObj);
//*this += *tObj;
sendTo(COLOR_OBJECTS, fmt("You remove %s to load it.\n\r") %
sstring(tObj->getName()).uncap().c_str());
}
}
if (heldInSecHand()) {
sendTo(COLOR_OBJECTS, fmt("You would have a hard time firing your %s, while holding %s.\n\r") % arg1 % sstring(heldInSecHand()->getName()).uncap());
return;
}
if (!(bow = searchLinkedListVis(this, arg1, getStuff()))) {
sendTo("Syntax : bload <bow> <arrow>\n\r");
return;
}
if(dynamic_cast<TGun *>(bow)){
sendTo("Use gload to load a gun.\n\r");
return;
} else {
arrow = findArrow(arg2, SILENT_NO);
if (arrow)
arrow->bloadBowArrow(this, bow);
else
sendTo(fmt("You seem to have run out of '%s's.\n\r") % arg2);
}
}
void TThing::bloadBowArrow(TBeing *ch, TThing *)
{
ch->sendTo("You can only load your bow with arrows!\n\r");
return;
}
void TThing::bloadArrowBow(TBeing *ch, TArrow *arrow)
{
ch->sendTo("Arrows are usually loaded into bows!\n\r");
return;
}
find_path avoids no-mob rooms now
/////////////////////////////////////////////////////////////////////////
//
// SneezyMUD - All rights reserved, SneezyMUD Coding Team
// "range.cc" - All functions and routines related to ranged combat
//
// Ranged systems coded by Russ Russell and Benjamin Youngdahl
//
/////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <map>
#include "stdsneezy.h"
#include "range.h"
#include "combat.h"
#include "obj_quiver.h"
#include "obj_bow.h"
#include "obj_portal.h"
#include "obj_arrow.h"
#include "obj_gun.h"
#define RANGE_DEBUG 0
const char *directions[][2] =
{
{"north", "from the south"},
{"east", "from the west"},
{"south", "from the north"},
{"west", "from the east"},
{"up", "from below"},
{"down", "from above"},
{"northeast", "from the southwest"},
{"northwest", "from the southeast"},
{"southeast", "from the northwest"},
{"southwest", "from the northeast"}
};
const char *dir_name[] =
{
"the north",
"the east",
"the south",
"the west",
"above",
"below",
"the northeast",
"the northwest",
"the southeast",
"the southwest",
};
int TThing::throwMe(TBeing *ch, dirTypeT tdir, const char *vict)
{
int iDist, rc;
unsigned int max_distance;
double mult;
TBeing *targ;
TThing *tmp;
unsigned int count;
char local_vict[256];
// a little physics....
// let the force I can throw something with be a function of my brawn
// F = f(brawn) = mass * accelleration
// acc = f(brawn)/m
float acc = ch->plotStat(STAT_CURRENT, STAT_BRA, 500.0, 5000.0, 2500.0);
acc /= max((float) 3.0, getWeight());
// regard acc as a ft/sec^2
// assume a throw has this constant acceleration for 0.2 secs
// which yields a final velocity v0x
float v0 = 0.2 * acc;
// regard this as ft/sec
// note, the values for acc's plotStat are roughly to correspond to
// avg human = 65 mph fastball, best human = 90 mph fast ball
// we fufged it and pretended baseball = 5lb (same as training dag)
// let's assume that they throw the object semi level to ground (no up angle)
// time aloft is then given by: h = 1/2 gt^2
// h being height thrown from, g = gravity
// using Earth's gravity of 32 ft/sec^2 and converting height to feet
float tt = sqrt(2 * (ch->getPartMinHeight(ITEM_WEAR_NECK)/12.0) / 32.0);
// regard this as secs
// lets toss in some "smarts" checking
// the above assumed the trajectory was at an up angle of 0 degrees
// if the thrower is smart, he'll realize he can throw further with an
// up angle. Since they are trying to hit a fixed distance target, they
// are really trying to solve a trajectory. This ain't easy so make the
// allowed angle be a function of int.
// 45 degrees is obscene range
int ang = ch->plotStat(STAT_CURRENT, STAT_FOC, 0, 45, 5);
// figure out the limiting angle
// i.e. above angle assumes I can safely throw a ballistic arc
// ceilings would prevent this...
if (ch->roomp->getRoomHeight() >= 0) {
// vf^2 = 2ax
// (vo sin(lim_ang))^2 = 2 * 32.0 * (room_height - my height)
float lim_ang = sqrt(2 * 32.0 * (ch->roomp->getRoomHeight() - ch->getPartMinHeight(ITEM_WEAR_NECK))/12.0 / v0 / v0);
lim_ang = asin(lim_ang);
lim_ang = lim_ang * 360.0 / 2 / M_PI; // convert from radians
ang = min(ang, (int) lim_ang);
}
ang = min(max(ang, 0), 45);
// and FINALLY, we translate all this into a range...
// the upangle range = v0^2/g sin 2(ang)
mult = ((v0 * v0)/32.0) * sin(2*ang*(2.0*M_PI/360.0));
// the above formula is for returning to same height we started from
// make allowance for how high we started from (from tt above)
mult += v0 * cos(ang * (2.0*M_PI/360.0)) * tt;
// regard the average "room" as 50 feet across, exterior = 100 ft across
if (ch->outside())
max_distance = (unsigned int) (mult / 100);
else
max_distance = (unsigned int) (mult / 50);
// this results in typical max distances of 3-4 rooms
// arbitrarily scale it so get 1-2 range limit
max_distance /= 2;
TObj *tobj = dynamic_cast<TObj *>(this);
if (tobj && !tobj->canWear(ITEM_THROW))
max_distance /= 2;
// allow it to go 1 room, people get pissy otherwise
max_distance = max(max_distance, (unsigned int) 1);
#if RANGE_DEBUG
char buf[256];
sprintf(buf, "Ranged debug: max_distance: %d\n\racceleration: %6.2f, velocity: %6.2f\n\rhangtime: %6.2f, angle: %d", max_distance, acc, v0, tt, ang);
vlogf(LOG_BUG, buf);
#endif
ch->learnFromDoingUnusual(LEARN_UNUSUAL_NORM_LEARN, SKILL_RANGED_PROF, 20);
strcpy(local_vict, vict);
if(sstring(local_vict).isNumber() && (sscanf(local_vict, "%d", &iDist) == 1))
*local_vict = '\0';
else
iDist = min(50, (int) max_distance);
if (iDist < 0) {
ch->sendTo("You need to supply a positive (or 0) distance to throw.\n\r");
return FALSE;
}
if (tdir == 4)
max_distance /= 2; // you can only throw upwards half as far
if ((iDist > 50) || (max_distance < (unsigned int) iDist)) {
ch->sendTo("Much too far. Maybe in your dreams!\n\r");
ch->sendTo(fmt("You couldn't possibly throw it further than %d rooms.\n\r") % max_distance);
return FALSE;
}
count = 0;
if (*local_vict)
targ = get_char_vis_direction(ch, local_vict, tdir, iDist, TRUE, &count);
else
targ = NULL;
if (targ && ch->checkPeacefulVictim("A strange force prevents you from contemplating hurting your target.\n\r", targ))
return FALSE;
if (targ && ch->noHarmCheck(targ))
return FALSE;
// treat fliers as being 1 room further away
if (targ && targ->isFlying() && ((count+1) > max_distance)) {
act("Unfortunately, $N is flying and you can't quite reach that far.",
FALSE, ch, 0, targ, TO_CHAR);
return FALSE;
}
act("You throw $p!", FALSE, ch, this, 0, TO_CHAR);
act("$n throws $p!", TRUE, ch, this, 0, TO_ROOM);
tmp = ch->unequip(ch->getPrimaryHold());
if (!tmp) {
vlogf(LOG_BUG, "Bad unequip in throwThing (%s : %s)", getName(), ch->getName());
ch->sendTo("Something real bad happened. Talk to a god.\n\r");
return FALSE;
}
*ch->roomp += *tmp;
rc = throwThing(this, tdir, ch->in_room, &targ, iDist, max_distance,ch);
if (IS_SET_DELETE(rc, DELETE_ITEM)) {
return DELETE_THIS;
}
if (IS_SET_DELETE(rc, DELETE_VICT)) {
delete targ;
targ = NULL;
}
ch->addToWait(combatRound(2));
ch->addToMove(-2);
rc = checkSpec(NULL, CMD_OBJ_THROWN, NULL, NULL);
if (IS_SET_DELETE(rc, DELETE_THIS))
return DELETE_THIS;
return TRUE;
}
void TBeing::doThrow(const sstring &argument)
{
TThing *t;
sstring object, dir, vict;
int rc;
dirTypeT tdir;
if (checkPeaceful("You feel too peaceful to contemplate violence.\n\r"))
return;
if (getMove() <= 2) {
sendTo("You are too tired to throw anything!\n\r");
return;
}
vict="";
object=argument.word(0);
dir=argument.word(1);
vict=argument.word(2);
if (object.empty()) {
sendTo("Syntax: throw <object> [direction] [character | distance]\n\r");
return;
}
tdir = getDirFromChar(dir);
if (tdir == DIR_NONE) {
vict=dir;
tdir = dirTypeT(::number(MIN_DIR, MAX_DIR-1));
}
if (vict.empty()) {
if (fight())
vict=fight()->name;
else
vict="mama-o-Brutius";
}
if (!(t = equipment[getPrimaryHold()])) {
sendTo("You can only throw objects you are holding in your primary hand.\n\r");
return;
}
TObj * tobj = dynamic_cast<TObj *>(t);
if (tobj) {
if (tobj->isObjStat(ITEM_NEWBIE)) {
sendTo("That item might suck, but you can't just go throwing it around.\n\r");
return;
}
if (tobj->isObjStat(ITEM_NODROP)) {
sendTo("You can't throw a cursed item!\n\r");
return;
}
}
if (!isname(object, t->name)) {
sendTo("You can only throw objects you are holding in your primary hand.\n\r");
return;
}
rc = t->throwMe(this, tdir, vict.c_str());
if (IS_SET_DELETE(rc, DELETE_THIS)) {
delete t;
t = NULL;
}
return;
}
int get_range_actual_damage(TBeing *ch, TBeing *victim, TObj *o, int dam, spellNumT attacktype)
{
if (ch->damCheckDeny(victim, attacktype))
return 0;
dam = victim->skipImmortals(dam);
if (!ch->damDetailsOk(victim, dam, TRUE))
return 0;
dam = ch->damageTrivia(victim, o, dam, attacktype);
// adjust the damage based on their skill
if (dam) {
int q;
if (dynamic_cast<TArrow *>(o)) {
// shot objects are here
// ranged spec basically allows arrow to do extra damage...
q = 100;
q += (ch->getSkillValue(SKILL_RANGED_PROF)/2); // 50%-100% damage
q += (ch->getSkillValue(SKILL_RANGED_SPEC)/2); // 100%-150% damage
dam *= q;
dam /= 100;
} else {
// thrown objects are here
q = ch->getSkillValue(SKILL_RANGED_PROF);
dam *= q;
dam /= 100;
}
dam = max(dam,1);
}
return (dam);
}
void pissOff(TMonster *irritated, TBeing *reason)
{
affectedData af;
const int PISSED_MOB_PERSIST = 250; // make em damn persistant
if (!(irritated->canSee(reason, INFRA_YES)) || reason->isImmortal())
return;
if (irritated->getPosition() >= POSITION_SLEEPING) {
if (!irritated->isDumbAnimal()) {
switch (dice(1, 10)) {
case 1:
act("$n screams 'I must kill $N!", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 2:
act("$n says 'That's it, $N is toast.'", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 3:
act("$n growls '$N must die'", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 4:
act("$n begins to curse about $N.", TRUE, irritated, 0, reason, TO_ROOM);
break;
case 5:
act("$n says 'Time to go killing.'", TRUE, irritated, 0, reason, TO_ROOM);
break;
default:
act("$n screams in rage!", TRUE, irritated, 0, reason, TO_ROOM);
break;
}
} else
irritated->aiGrowl(NULL);
SET_BIT(irritated->specials.act, ACT_HUNTING);
irritated->specials.hunting = reason;
irritated->hunt_dist = -500; // -500 means mobs will open doors!
irritated->persist = PISSED_MOB_PERSIST;
irritated->oldRoom = irritated->inRoom();
irritated->addHated(reason);
if (!irritated->affectedBySpell(SPELL_TRAIL_SEEK)) {
af.type = SPELL_TRAIL_SEEK; // make sure mob hunts global
af.duration = PISSED_MOB_PERSIST;
af.modifier = 0;
af.location = APPLY_NONE;
af.bitvector = 0;
irritated->affectTo(&af);
}
}
}
// ch is thrower of thing (sometimes NULL - falling objects)
// vict is potential victim
bool hitInnocent(const TBeing *ch, const TThing *thing, const TThing *vict)
{
// hit innocent due to misthrow
const TBeing * tbc = dynamic_cast<const TBeing *>(vict);
if (ch) {
if (ch->isImmortal())
return FALSE;
// presume anyone near thrower is safely out of the way
if (tbc && tbc->sameRoom(*ch))
return false;
// protect the mounts of group members too
if (tbc && tbc->rider) {
TBeing *temp = dynamic_cast<TBeing *>(tbc->horseMaster());
if (temp && temp->inGroup(*ch) && temp->sameRoom(*ch))
return false;
}
}
float num;
// size of target
num = vict->getHeight();
num *= vict->getWeight();
num /= 1000;
// num should be on order of 15 - 70
num += 1 + thing->getVolume()/1000;
if (ch) {
num -= ch->plotStat(STAT_CURRENT, STAT_AGI, -10, 10, 0);
}
if (tbc) {
num -= tbc->plotStat(STAT_CURRENT, STAT_PER, -5, 5, 0);
num -= tbc->plotStat(STAT_CURRENT, STAT_SPE, -5, 5, 0);
}
return (::number(20, 100) < num);
}
// returns DELETE_ITEM if *thing should be nuked
// returns DELETE_VICT if *targ should go poof (|| able)
// return TRUE if it hits something (stops moving), otherwise false
// cdist = current dist traveled
// mdist = max range item can go
int catch_or_smack(TRoom *rp, TBeing **targ, TThing *thing, TBeing *ch, int cdist, int mdist)
{
return thing->catchSmack(ch, targ, rp, cdist, mdist);
}
int TThing::catchSmack(TBeing *ch, TBeing **targ, TRoom *rp, int cdist, int mdist)
{
TThing *c, *c_next;
int d = 0;
bool true_targ;
int i;
int resCode = 0;
int damtype;
int range;
damtype = getWtype();
for (c = rp->getStuff(); c; c = c_next) {
c_next = c->nextThing;
TBeing *tbt = dynamic_cast<TBeing *>(c);
if (!tbt || (tbt == ch))
continue;
// range is sort of a modified cdist
if (tbt->isFlying())
range = cdist + 1;
else
range = cdist;
// anyone we want to hit here? (including innocents)
// the ch->isImmortal() checks prevent gods from hitting innocents
if ((true_targ = (tbt == *targ)) ||
hitInnocent(ch, this, tbt)) {
// if we hit an innocent, treat range as being greater so that damage
// is less than if it was intentional
if (!true_targ && range != mdist)
range++;
if ((::number(1, 25) < tbt->plotStat(STAT_CURRENT, STAT_SPE, 3, 18, 13)) &&
tbt->hasHands() && !tbt->bothHandsHurt() &&
tbt->awake() && tbt->canGet(this, SILENT_YES)) {
resCode = TRUE;
act("$n catches $p.", FALSE, tbt, this, NULL, TO_ROOM);
if (!ch->sameRoom(*tbt))
act("In the distance, $N catches your $o.",TRUE,ch,this,tbt,TO_CHAR);
if (!tbt->heldInPrimHand()) {
act("You catch $p.",
FALSE,tbt,this,0,TO_CHAR);
--(*this);
tbt->equipChar(this, tbt->getPrimaryHold());
} else if (!tbt->heldInSecHand()) {
act("You catch $p.",
FALSE,tbt,this,0,TO_CHAR);
--(*this);
tbt->equipChar(this, tbt->getSecondaryHold());
} else {
act("You catch $p, and add it to your inventory.",
FALSE,tbt,this,0,TO_CHAR);
--(*this);
*tbt += *this;
}
if (!tbt->isPc())
pissOff(dynamic_cast<TMonster *>(tbt), ch);
if (cdist == 0)
ch->setCharFighting(tbt, 0);
return resCode;
} else if (!ch->isImmortal() &&
(!(i = ch->specialAttack(tbt, SKILL_RANGED_PROF)) ||
i == GUARANTEED_FAILURE)) {
act("$n dodges out of the way of $p.", FALSE, tbt, this, NULL, TO_ROOM);
tbt->sendTo("You dodge out of its way.\n\r");
if (!ch->sameRoom(*tbt))
act("In the distance, $N dodges out of the way of $p.",
TRUE,ch,this,tbt,TO_CHAR);
resCode = FALSE;
if (!tbt->isPc())
pissOff(dynamic_cast<TMonster *>(tbt), ch);
if (cdist == 0)
ch->setCharFighting(tbt, 0);
return resCode;
} else {
// smacked by non-weapon/arrow
if (true_targ)
act("$n is smacked by $p!", FALSE, tbt, this, NULL, TO_ROOM);
else
act("$n is accidentally smacked by $p!", FALSE, tbt, this, NULL, TO_ROOM);
act("You are unable to dodge being hit by $p!",
FALSE, tbt, this, NULL, TO_CHAR);
if (!ch->sameRoom(*tbt))
act("In the distance, $N is hit by $p.",TRUE,ch,this,tbt,TO_CHAR);
resCode = TRUE;
d = min(max(0, (int) (getWeight() - 5)), 10);
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) dam ping 1: %d", d);
#endif
// don't do this or we wind up with acorns killing people
// d *= mdist - range + 1; // modify for point blank range - bat
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) dam ping 3: %d", d);
#endif
TObj *tobj = dynamic_cast<TObj *>(this);
if (tobj) {
d = get_range_actual_damage(ch, tbt, tobj, d, TYPE_HIT);
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) dam ping 4: %d", d);
#endif
if (::number(1, d) <= tobj->getStructPoints() &&
tbt->roomp && !tbt->roomp->isRoomFlag(ROOM_ARENA)) {
tobj->addToStructPoints(-1);
if (tobj->getStructPoints() <= 0) {
if (!ch->sameRoom(*tbt))
act("In the distance, $p is destroyed.",TRUE,ch,tobj,0,TO_CHAR);
tobj->makeScraps();
ADD_DELETE(resCode, DELETE_ITEM);
}
}
#if RANGE_DEBUG
vlogf(LOG_BUG, "Range debug: (2) %s damaging %s with %s for %d dam",
ch->getName(), tbt->getName(), tobj->getName(), d);
#endif
if (ch->reconcileDamage(tbt, d, getWtype()) == -1) {
if (true_targ) {
ADD_DELETE(resCode, DELETE_VICT);
return resCode;
}
delete tbt;
tbt = NULL;
return resCode;
}
}
if (tbt && !tbt->isPc())
pissOff(dynamic_cast<TMonster *>(tbt), ch);
if (cdist == 0)
ch->setCharFighting(tbt, 0);
if (true_targ)
*targ = tbt;
return resCode;
}
}
}
return FALSE;
}
int hit_obstacle_in_room(TRoom *rp, TThing *thing, TBeing *ch)
{
TThing *t;
for (t = rp->getStuff(); t; t = t->nextThing) {
TObj *obj = dynamic_cast<TObj *>(t);
if (obj) {
if ((obj != thing) && (!number(0, 4)) && (obj->getVolume() > 10000) &&
(obj->getVolume() > ((dice(1, 1000) * 1000)) - thing->getVolume())) {
act("$n smacks into $N, and falls to the $g.",
TRUE, thing, 0, obj, TO_ROOM);
act("$p smacked into $N.", FALSE, ch, thing, obj, TO_CHAR);
if (thing->spec) thing->checkSpec(NULL, CMD_ARROW_HIT_OBJ, "", obj);
return TRUE;
}
}
}
return FALSE;
}
static void barrier(TRoom *rp, dirTypeT dir, TThing *t)
{
char buf[256];
switch (rp->getSectorType()) {
case SECT_TROPICAL_BUILDING:
case SECT_TEMPERATE_BUILDING:
case SECT_ARCTIC_BUILDING:
case SECT_TROPICAL_CAVE:
case SECT_TEMPERATE_CAVE:
case SECT_ARCTIC_CAVE:
if (dir == 5)
sprintf(buf, "$n glances off the $g at a strange angle and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n bounces off the ceiling and drops to the $g.");
else
sprintf(buf, "$n bounces off a wall and drops to the $g.");
break;
case SECT_ARCTIC_CITY:
case SECT_TEMPERATE_CITY:
case SECT_TROPICAL_CITY:
if (dir == 5)
sprintf(buf, "$n glances off the $g at a strange angle and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n sails briefly into the air above before falling to the $g.");
else
sprintf(buf, "$n bounces off a wall and drops to the $g.");
break;
case SECT_JUNGLE:
case SECT_RAINFOREST:
case SECT_TEMPERATE_FOREST:
case SECT_ARCTIC_FOREST:
if (dir == 5)
sprintf(buf, "$n glances off a stump and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n bounces off a branch above before falling to the $g.");
else
sprintf(buf, "$n flies through the air a ways before hitting a tree.");
break;
case SECT_ARCTIC_RIVER_SURFACE:
case SECT_ICEFLOW:
case SECT_TEMPERATE_OCEAN:
case SECT_TEMPERATE_RIVER_SURFACE:
case SECT_TROPICAL_RIVER_SURFACE:
case SECT_TROPICAL_OCEAN:
if (dir == 5)
sprintf(buf, "$n splashes into the water.");
else if (dir == 4)
sprintf(buf, "$n flies into the air, and falls into the water below.");
else
sprintf(buf, "$n flies through the air a ways before splashing into the water.");
break;
case SECT_TROPICAL_UNDERWATER:
case SECT_TEMPERATE_UNDERWATER:
sprintf(buf, "$n is slowed to a halt by the water.");
break;
case SECT_TROPICAL_ATMOSPHERE:
case SECT_TEMPERATE_ATMOSPHERE:
case SECT_ARCTIC_ATMOSPHERE:
sprintf(buf, "$n loses momentum and begins to fall!");
break;
case SECT_DESERT:
case SECT_TROPICAL_BEACH:
case SECT_TEMPERATE_BEACH:
case SECT_COLD_BEACH:
case SECT_ARCTIC_MARSH:
case SECT_TEMPERATE_SWAMP:
case SECT_TROPICAL_SWAMP:
if (dir == 5)
sprintf(buf, "$n slams into the $g and comes to a stop.");
else
sprintf(buf, "$n flies a short distance before crashing into the $g.");
break;
case SECT_SOLID_ICE:
sprintf(buf, "$n slams into a chunk of ice and gets stuck.");
break;
case SECT_SOLID_ROCK:
sprintf(buf, "$n glances off a rock outcropping and stops flying.");
break;
case SECT_ASTRAL_ETHREAL:
sprintf(buf, "A weird distortion in the matrix stops $n from flying.");
break;
case SECT_FIRE:
case SECT_VOLCANO_LAVA:
if (dir == 5)
sprintf(buf, "$n disappears as it hits the flaming molten surface below.");
else
sprintf(buf, "$n goes a short ways before falling into the flaming surface below.");
break;
case SECT_SUBARCTIC:
case SECT_ARCTIC_WASTE:
case SECT_ARCTIC_ROAD:
case SECT_TUNDRA:
case SECT_ARCTIC_MOUNTAINS:
case SECT_PLAINS:
case SECT_TEMPERATE_ROAD:
case SECT_GRASSLANDS:
case SECT_TEMPERATE_HILLS:
case SECT_TEMPERATE_MOUNTAINS:
case SECT_SAVANNAH:
case SECT_VELDT:
case SECT_TROPICAL_ROAD:
case SECT_TROPICAL_HILLS:
case SECT_TROPICAL_MOUNTAINS:
default:
if (dir == 5)
sprintf(buf, "$n glances off the $g at a strange angle and comes to rest.");
else if (dir == 4)
sprintf(buf, "$n sails briefly into the air above before falling to the $g.");
else
sprintf(buf, "$n flies through the air a ways before dropping to the $g.");
}
act(buf, TRUE, t, 0, 0, TO_ROOM);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
}
// max_dist is the maximum distance that "o" can be thrown.
// iDist is how far user wants item to go
// distance is actual amount flown
// return DELETE_ITEM if t should go poof
// returns DELETE_VICT if *targ should die (|| able)
int throwThing(TThing *t, dirTypeT dir, int from, TBeing **targ, int dist, int max_dist, TBeing *ch)
{
char capbuf[256];
TRoom *rp, *newrp;
int iDist = 0;
int rc;
// send the thing up to "dist" rooms away, checking for our target
while ((rp = real_roomp(from))) {
if (iDist) {
sprintf(capbuf, "$n %s into the room %s.", (dir == 5 ? "drops" : "flies"), directions[dir][1]);
act(capbuf, TRUE, t, 0, 0, TO_ROOM);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_INTO_ROOM, "", NULL);
} else {
if (t->spec) t->checkSpec(NULL, CMD_ARROW_SHOT, "", NULL);
}
if (hit_obstacle_in_room(rp, t, ch))
return FALSE;
// max_dist here is used to modify damage based on how far away they are.
// use the absolute max it can go (max_dist) for this calculation
rc = catch_or_smack(rp, targ, t, ch, iDist, max_dist);
if (IS_SET_DELETE(rc, DELETE_ITEM) || IS_SET_DELETE(rc, DELETE_VICT))
return rc;
else if (rc)
return FALSE;
// users specified to fly "dist" rooms, so probably only provided
// momentum for that far. Use dist in this check, rather than max_dist
iDist++;
if (iDist > dist || iDist > max_dist) {
act("$n drops to the $g.", TRUE, t, 0, 0, TO_ROOM);
if (dir != DIR_DOWN)
act("$p ran out of momentum and fell.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
} else if (!clearpath(from, dir) || rp->isUnderwaterSector()) {
barrier(rp, dir,t);
act("$p hit an obstacle and dropped to the $g.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
}
// No need to check for a NULL newrp, clearpath() does that. - Russ
newrp = real_roomp(rp->dir_option[dir]->to_room);
if (newrp->isRoomFlag(ROOM_PEACEFUL) || newrp->isRoomFlag(ROOM_NO_MOB)) {
act("Strangely, $n hits a magical barrier and falls to the $g.",
FALSE, t, 0, 0, TO_ROOM);
act("$p hit a magic barrier and dropped to the $g.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
}
if (newrp->isRoomFlag(ROOM_NO_HEAL)) {
act("Strangely, $n hits a magical barrier and falls to the $g.",
FALSE, t, 0, 0, TO_ROOM);
act("$p hit a magic barrier and dropped to the $g.", FALSE, ch, t, 0, TO_CHAR);
if (t->spec) t->checkSpec(NULL, CMD_ARROW_MISSED, "", NULL);
return FALSE;
}
sprintf(capbuf, "$n %s %s out of the room.", (dir == 5 ? "drops" : "flies"), directions[dir][0]);
act(capbuf, TRUE, t, 0, 0, TO_ROOM);
--(*t);
from = rp->dir_option[dir]->to_room;
*(real_roomp(from)) += *t;
}
if (!rp) {
vlogf(LOG_BUG, "%s thrown into non-existant room #%d", capbuf, from);
--(*t);
thing_to_room(t, ROOM_VOID);
return FALSE;
}
return FALSE;
}
// ch attempts to see targ by looking linearly in all cardinal directions
// returns the direction targ was spotted in, or -1 (failure)
// range and dir are also passed as formal vars
dirTypeT can_see_linear(const TBeing *ch, const TBeing *targ, int *rng, dirTypeT *dr)
{
int rm, max_range = 15, range = 0;
int height = 0;
// add bonus from race
max_range += ch->getMyRace()->getLOS();
max_range += (ch->visionBonus + 1)/2;
switch (ch->getPosition()) {
case POSITION_MOUNTED:
height = 4*dynamic_cast<TBeing *>(ch->riding)->getHeight()/5 + 2*ch->getHeight()/3;
break;
case POSITION_STANDING:
case POSITION_FIGHTING:
height = ch->getHeight();
break;
case POSITION_SITTING:
height = ch->getHeight()/3;
break;
case POSITION_CRAWLING:
height = ch->getHeight()/4;
break;
case POSITION_RESTING:
case POSITION_SLEEPING:
default:
height = ch->getHeight()/6;
break;
}
if (height > 80)
max_range += 2;
else if (height > 75)
max_range += 1;
else if (height < 60)
max_range -= 2;
else if (height < 65)
max_range -= 1;
if ((ch->age()->year - ch->getBaseAge() + 17) > 80)
max_range -= 3;
else if ((ch->age()->year - ch->getBaseAge() + 17) > 60)
max_range -= 2;
else if ((ch->age()->year - ch->getBaseAge() + 17) > 40)
max_range -= 1;
else if ((ch->age()->year - ch->getBaseAge() + 17) < 20)
max_range += 1;
if ((ch->roomp->getWeather() == WEATHER_RAINY) ||
(ch->roomp->getWeather() == WEATHER_LIGHTNING))
max_range /= 2;
else if (ch->roomp->getWeather() == WEATHER_SNOWY)
max_range /= 4;
dirTypeT i;
for (i = MIN_DIR; i < MAX_DIR; i++) {
rm = ch->in_room;
range = 0;
while (range < max_range) {
range++;
max_range -= TerrainInfo[real_roomp(rm)->getSectorType()]->thickness;
if (clearpath(rm, i)) {
rm = real_roomp(rm)->dir_option[i]->to_room;
const TThing *t;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
if ((t == targ) && ch->canSee(t)) {
*rng = range;
*dr = i;
return i;
}
}
}
}
}
return DIR_NONE;
}
TBeing *get_char_linear(const TBeing *ch, char *arg, int *rf, dirTypeT *df)
{
int rm, max_range = 15, range = 0, n, n_sofar = 0;
TThing *t;
char *tmp, tmpname[256];
if ((ch->getRace() == RACE_ELVEN) || (ch->getRace() == RACE_DROW))
max_range += 5;
max_range += (ch->visionBonus + 1)/2;
if ((ch->roomp->getWeather() == WEATHER_RAINY) ||
(ch->roomp->getWeather() == WEATHER_LIGHTNING))
max_range /= 2;
else if (ch->roomp->getWeather() == WEATHER_SNOWY)
max_range /= 4;
strcpy(tmpname, arg);
tmp = tmpname;
if (!(n = get_number(&tmp)))
return NULL;
// This routine counts folks in your room
rm = ch->in_room;
dirTypeT i = DIR_NONE;
range = 0;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
TBeing *tbt = dynamic_cast<TBeing *>(t);
if (tbt && (isname(tmp, tbt->name)) && ch->canSee(tbt)) {
n_sofar++;
if (n_sofar == n) {
*rf = range;
*df = DIR_NONE;
return tbt;
}
}
}
for (i = MIN_DIR; i < MAX_DIR; i++) {
rm = ch->in_room;
range = 0;
while (range < max_range) {
range++;
max_range -= TerrainInfo[real_roomp(rm)->getSectorType()]->thickness;
if (clearpath(rm, i)) {
rm = real_roomp(rm)->dir_option[i]->to_room;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
TBeing *tbt = dynamic_cast<TBeing *>(t);
if (tbt && (isname(tmp, tbt->getName())) && ch->canSee(tbt)) {
n_sofar++;
if (n_sofar == n) {
*rf = range;
*df = i;
return tbt;
}
}
}
} else
range = max_range + 1;
}
}
return NULL;
}
int clearpath(int room, dirTypeT dir)
{
TRoom *rp;
rp = real_roomp(room);
if (!rp || !rp->dir_option[dir])
return FALSE;
if (rp->dir_option[dir]->to_room < 1)
return FALSE;
if (!real_roomp(rp->dir_option[dir]->to_room)) {
vlogf(LOG_BUG, "Range function done in room with bad exit. (%d) Dir:[%d]", room, dir);
return FALSE;
}
if (IS_SET(rp->dir_option[dir]->condition, EX_CLOSED))
return FALSE;
return (real_roomp(room)->dir_option[dir]->to_room);
}
void TBeing::doScan(const char *argument)
{
const char *rng_desc[] =
{
"right here", // 0
"immediately",
"nearby",
"a short ways",
"not too far",
"a ways", // 5 room
"quite a ways",
"way off",
"way off",
"far",
"far", // 10 rooms
"way way off",
"way way off",
"real far",
"real far",
"very far", // 15 rooms
"very far",
"extremely far",
"extremely far",
"on the horizon",
"on the horizon", // 20 rooms
"on the horizon",
"on the horizon",
"on the horizon",
"on the horizon"
};
char buf[256], buf2[256];
char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH];
int max_range = 15, range, new_rm, rm, nfnd;
int hindered;
bool found = FALSE;
TThing *t;
bool all = FALSE;
argument_split_2(argument, arg1, arg2);
float swt;
dirTypeT sd = getDirFromChar(arg1);
dirTypeT smin, smax;
if (sd == DIR_NONE) {
smin = MIN_DIR;
smax = dirTypeT(MAX_DIR-1);
swt = 1.5;
sprintf(buf, "$n peers intently all around.");
sprintf(buf2, "You peer intently all around, and see :\n\r");
all = TRUE;
} else {
smin = sd;
smax = sd;
swt = 0.5;
sprintf(buf, "$n peers intently %s.", dirs_to_blank[sd]);
sprintf(buf2, "You peer intently %s, and see :\n\r", dirs_to_blank[sd]);
}
if (getMove() < (all ? 10 : 2)) {
sendTo("You are simply too exhausted!\n\r");
return;
}
act(buf, TRUE, this, 0, 0, TO_ROOM);
sendTo(buf2);
if (!inLethargica())
addToMove(all ? -10 : -2);
if (isAffected(AFF_BLIND) && !isAffected(AFF_TRUE_SIGHT)) {
sendTo("Nothing, you are blind.\n\r");
return;
}
nfnd = 0;
// Check in room first
if (all) {
// for specific directions, skip room so it doesn't count toward "nfnd"
for (t = roomp->getStuff(); t; t = t->nextThing) {
if (!dynamic_cast<TBeing *>(t))
continue;
if (t == this)
continue;
if (canSee(t)) {
sendTo(COLOR_MOBS, fmt("%30s : right here\n\r") % t->getNameNOC(this));
found = TRUE;
} else if (canSee(t, INFRA_YES)) {
sendTo(COLOR_MOBS, fmt("%30s : right here\n\r") % "A blob of heat");
found = TRUE;
}
}
}
max_range -= TerrainInfo[roomp->getSectorType()]->thickness;
max_range += (visionBonus / 10);
// Let weather conditions play a part in range - Russ 10/14/98
// silly immortal check, but imms gripe about it
if (!isImmortal()) {
if (roomp->getWeather() == WEATHER_SNOWY) {
max_range -= 3;
sendTo(COLOR_BASIC, "The <W>SNOW<1> greatly decreases your view!\n\r");
} else if (roomp->getWeather() == WEATHER_RAINY) {
max_range -= 2;
sendTo(COLOR_BASIC, "The <B>RAIN<1> decreases your view!\n\r");
} else if (roomp->getWeather() == WEATHER_CLOUDY) {
max_range -= 1;
sendTo(COLOR_BASIC, "The <k>FOG<1> slightly decreases your view!\n\r");
//sendTo(COLOR_BASIC, "The <k>CLOUDS<1> slightly decrease your view!\n\r");
} else if (roomp->getWeather() == WEATHER_CLOUDLESS) {
max_range += 1;
sendTo(COLOR_BASIC, "The <c>clear skies<1> enhance your view!\n\r");
}
}
dirTypeT i;
for (i = smin; i <= smax; i++) {
nfnd = 0;
hindered = FALSE;
rm = in_room;
range = 0;
while ((range < max_range) && !hindered) {
range++;
if (clearpath(rm, i)) {
new_rm = real_roomp(rm)->dir_option[i]->to_room;
if (new_rm == rm)
break;
else
rm = new_rm;
for (t = real_roomp(rm)->getStuff(); t; t = t->nextThing) {
TBeing *tbt = dynamic_cast<TBeing *>(t);
if (!tbt)
continue;
if (can_see_char_other_room(this, tbt, real_roomp(rm))) {
sendTo(COLOR_MOBS, fmt("%30s : %s %s\n\r") % tbt->getNameNOC(this) % rng_desc[range] % dirs_to_blank[i]);
nfnd++;
found = TRUE;
if (nfnd > (5 + visionBonus / 3)) {
sendTo(fmt("The crowd hinders you from seeing any further %s.\n\r") % dirs_to_blank[i]);
hindered = TRUE;
break;
}
} else if (canSee(tbt, INFRA_YES)) {
sendTo(COLOR_MOBS, fmt("%30s : %s %s\n\r") % "A blob of heat" % rng_desc[range] % dirs_to_blank[i]);
nfnd++;
found = TRUE;
if (nfnd > (5 + visionBonus / 3)) {
sendTo(fmt("The crowd hinders you from seeing any further %s.\n\r") % dirs_to_blank[i]);
hindered = TRUE;
break;
}
}
}
} else
range = max_range + 1;
}
}
if (!found)
sendTo("Nothing.\n\r");
addToWait(combatRound(swt));
}
// returns DELETE_THIS
int TBeing::stickIn(TThing *o, wearSlotT pos, silentTypeT silent)
{
int rc;
char buf[80];
if ((pos == HOLD_RIGHT)) {
pos = WEAR_HAND_R;
} else if (pos == HOLD_LEFT) {
pos = WEAR_HAND_L;
}
mud_assert(!o->equippedBy && !o->parent && (o->in_room == -1),
"stickIn: item had owner at invocation");
mud_assert(pos >= MIN_WEAR && pos < MAX_WEAR,
"Bad slot in stickIn, %s %d", getName(), pos);
mud_assert(slotChance(pos),
"No slot chance in stickIn, %s %d", getName(), pos);
mud_assert(getStuckIn(pos) == NULL,
"stickIn: bodyPart had item stuckIn already");
mud_assert(roomp != NULL,
"stickIn: ch with no roomp");
setStuckIn(pos, o);
o->eq_stuck = pos;
o->stuckIn = this;
if (!silent) {
sprintf(buf, "$p sticks in $n's %s!", describeBodySlot(pos).c_str());
act(buf, FALSE, this, o, 0, TO_ROOM);
sprintf(buf, "$p sticks in your %s!", describeBodySlot(pos).c_str());
act(buf, FALSE, this, o, 0, TO_CHAR);
}
TObj *obj = dynamic_cast<TObj *>(o);
if (obj && obj->spec) {
rc = ((objSpecials[GET_OBJ_SPE_INDEX(obj->spec)].proc)
(this, CMD_OBJ_STUCK_IN, "", obj, NULL));
if (IS_SET_DELETE(rc, DELETE_THIS))
return DELETE_THIS;
}
return TRUE;
}
TThing *has_range_object(TBeing *ch, int *pos)
{
TThing *hucked;
TObj *tobj;
if (!ch->equipment[HOLD_RIGHT] && !ch->equipment[HOLD_LEFT] && !ch->getStuff())
return NULL;
// Go thru possible places for throwing objects.
if ((hucked = ch->equipment[HOLD_RIGHT])) {
tobj = dynamic_cast<TObj *>(hucked);
if (tobj && tobj->canWear(ITEM_THROW)) {
*pos = HOLD_RIGHT;
return (tobj);
}
} else if ((hucked = ch->equipment[HOLD_LEFT])) {
tobj = dynamic_cast<TObj *>(hucked);
if (tobj && tobj->canWear(ITEM_THROW)) {
*pos = HOLD_LEFT;
return (tobj);
}
} else {
for (TThing *t = ch->getStuff(); t; t = t->nextThing) {
tobj = dynamic_cast<TObj *>(t);
if (tobj && tobj->canWear(ITEM_THROW)) {
*pos = -1;
return tobj;
}
}
}
return NULL;
}
// ----------------------------------------------
int go_ok(roomDirData *exitp)
{
return (!IS_SET(exitp->condition, EX_CLOSED | EX_LOCKED | EX_SECRET) &&
(exitp->to_room != ROOM_NOWHERE));
}
int go_ok_smarter(roomDirData *exitp)
{
return (!IS_SET(exitp->condition, EX_LOCKED | EX_SECRET) &&
(exitp->to_room != ROOM_NOWHERE));
}
#if 0
static void donothing(void *);
static void donothing(void *)
{
return;
}
#endif
class pathData {
public:
dirTypeT direct;
int source;
bool checked;
pathData() : direct(DIR_NONE), source(0), checked(false) {}
};
// returns DIR_NONE1 indicating a problem or can't find a path
// returns 0-9 indicating a direction to travel
// returns 10+ indicating a portal to enter (10 = first in room, 11 = 2nd,...)
dirTypeT find_path(int room, int (*pred) (int, void *), void *data, int depth, bool in_zone, int *answer, bool use_portals)
{
// just to be dumb, check my own room first
if ((pred) (room, data)) {
if (answer)
*answer = room;
return DIR_NONE;
}
bool thru_doors;
if (depth < 0) {
thru_doors = true;
depth = -depth;
} else
thru_doors = false;
// create this room as a starting point
pathData *pd = new pathData();
pd->direct = DIR_NONE;
pd->source = -1;
pd->checked = false;
map<int, pathData *>path_map;
path_map[room] = pd;
for(;;) {
map<int, pathData *>::const_iterator CI;
map<int, pathData *>next_map;
if (path_map.size() > (unsigned int) depth) {
if (answer)
*answer = path_map.size();
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI) {
pd = CI->second;
delete pd;
}
for (CI = next_map.begin(); CI != next_map.end(); ++CI) {
pd = CI->second;
delete pd;
}
return DIR_NONE;
}
for (CI = path_map.begin(); CI != path_map.end(); ++CI) {
// no need to do things twice
pd = CI->second;
if (pd->checked)
continue;
dirTypeT dir;
TRoom *rp = real_roomp(CI->first);
if (!rp) {
vlogf(LOG_BUG, "Problem iterating path map.");
continue;
}
if(!use_portals){
for (dir = MIN_DIR; dir < MAX_DIR; dir++) {
roomDirData *exitp = rp->dir_option[dir];
TRoom *hp = NULL;
if (exitp &&
(hp = real_roomp(exitp->to_room)) &&
!(hp->isRoomFlag(ROOM_NO_MOB)) &&
(thru_doors ? go_ok_smarter(exitp) : go_ok(exitp))) {
// check in_zone criteria
if (in_zone && (hp->getZoneNum() != rp->getZoneNum())) {
continue;
}
// do we have this room already?
map<int, pathData *>::const_iterator CT;
CT = path_map.find(exitp->to_room);
if (CT != path_map.end())
continue;
CT = next_map.find(exitp->to_room);
if (CT != next_map.end())
continue;
// is this our target?
if ((pred) (exitp->to_room, data)) {
// found our target, walk our list backwards
if (answer)
*answer = exitp->to_room;
pd = CI->second;
for (;;) {
if (pd->source == -1) {
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI) {
pathData *tpd = CI->second;
delete tpd;
}
for (CI = next_map.begin(); CI != next_map.end(); ++CI) {
pathData *tpd = CI->second;
delete tpd;
}
return dir;
}
dir = pd->direct;
pd = path_map[pd->source];
}
}
// it's not our target, and we don't have this room yet
pd = new pathData();
pd->source = CI->first;
pd->direct = dir;
pd->checked = false;
next_map[exitp->to_room] = pd;
}
}
}
// check for portals that might lead to target
// return 10 if its the 1st portal in the room, 11 for 2nd, etc
// 0-9 are obviously real exits (see above)
if (thru_doors || use_portals) {
dir = dirTypeT(MAX_DIR-1);
TThing *t;
for (t = rp->getStuff(); t; t = t->nextThing) {
TPortal *tp = dynamic_cast<TPortal *>(t);
if (!tp)
continue;
dir++; // increment portal
if (tp->isPortalFlag(EX_LOCKED | EX_CLOSED))
continue;
int tmp_room = tp->getTarget(); // next room
TRoom *hp = real_roomp(tmp_room);
if (!hp) {
continue;
}
// check in_zone criteria
if (in_zone && (hp->getZoneNum() != rp->getZoneNum())) {
continue;
}
// do we have this room already?
map<int, pathData *>::const_iterator CT;
CT = path_map.find(tmp_room);
if (CT != path_map.end())
continue;
CT = next_map.find(tmp_room);
if (CT != next_map.end())
continue;
// is this our target?
if ((pred) (tmp_room, data)) {
// found our target, walk our list backwards
if (answer)
*answer = tmp_room;
pd = CI->second;
for (;;) {
if (pd->source == -1) {
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI)
delete CI->second;
for (CI = next_map.begin(); CI != next_map.end(); ++CI)
delete CI->second;
return dir;
}
dir = pd->direct;
pd = path_map[pd->source];
}
}
// it's not our target, and we don't have this room yet
pd = new pathData();
pd->source = CI->first;
pd->direct = dir;
pd->checked = false;
next_map[tmp_room] = pd;
} // stuff in room
}
// end portal check
// we've checked all dirs for this room, so mark it checked
pd = CI->second;
pd->checked = true;
}
// if we failed to find any new rooms, abort, or be in an endless loop
if (next_map.size() == 0) {
if (answer)
*answer = ROOM_NOWHERE;
// clean up allocated memory
for (CI = path_map.begin(); CI != path_map.end(); ++CI)
delete CI->second;
for (CI = next_map.begin(); CI != next_map.end(); ++CI)
delete CI->second;
return DIR_NONE;
}
// we've looped over the entire map list, so move the next_map values in
for (CI = next_map.begin(); CI != next_map.end(); ++CI) {
path_map[CI->first] = CI->second;
}
next_map.clear();
}
}
dirTypeT choose_exit_global(int in_room, int tgt_room, int depth)
{
return find_path(in_room, is_target_room_p, (void *) tgt_room, depth, 0);
}
dirTypeT choose_exit_in_zone(int in_room, int tgt_room, int depth)
{
return find_path(in_room, is_target_room_p, (void *) tgt_room, depth, 1);
}
int TBeing::doShoot(const char *arg)
{
char arg1[128], arg2[128];
TBeing *targ = NULL;
int rc, iDist;
dirTypeT dir;
TThing *t;
unsigned int count = 0;
// Prevent: order elemental shoot <blah>
// for Free xp.
if ((!desc || (!isPc() && !orig)) && !(spec)) //added spec for the BM archers.. hopefully wont cause problems - Dash
return FALSE;
rc = sscanf(arg, "%s %s %d", arg2, arg1, &iDist);
if (rc < 3)
iDist = 99;
if (rc < 2)
*arg1='\0';
if (rc < 1 || rc > 3) {
sendTo("Syntax : shoot <direction> <creature> <max-distance>\n\r");
return FALSE;
}
dir = getDirFromChar(arg2);
if (dir == DIR_NONE) {
strcpy(arg1, arg2);
dir = dirTypeT(::number(MIN_DIR, MAX_DIR-1));
}
if (checkPeaceful("You feel much too peaceful to contemplate violence.\n\r"))
return FALSE;
if (!(t = equipment[getPrimaryHold()])) {
sendTo("You are not holding a bow to shoot!\n\r");
return FALSE;
}
if (getSkillValue(SKILL_RANGED_PROF) <= 0 && !dynamic_cast<TGun *>(t)) {
sendTo("You almost shoot yourself in the foot!\n\r");
sendTo("You realize you don't have any clue what you're doing...get some training.\n\r");
return FALSE;
}
if (arg1 && *arg1 &&
!(targ = get_char_vis_direction(this, arg1, dir, iDist, TRUE, &count))) {
sendTo("No creature with that name in that room.\n\r");
sendTo("Syntax : shoot <direction> <creature> <max-distance>\n\r");
return FALSE;
}
rc = t->shootMeBow(this, targ, count, dir, iDist);
if (IS_SET_DELETE(rc, DELETE_THIS)) {
delete t;
t = NULL;
}
if (IS_SET_DELETE(rc, DELETE_VICT)) {
return DELETE_THIS;
}
// this is mainly for dual wielding guns, bows should be 2-handed
if((t = equipment[getSecondaryHold()]) &&
dynamic_cast<TObj *>(t) && !dynamic_cast<TObj *>(t)->usedAsPaired()){
rc = t->shootMeBow(this, targ, count, dir, iDist);
if (IS_SET_DELETE(rc, DELETE_THIS)) {
delete t;
t = NULL;
}
if (IS_SET_DELETE(rc, DELETE_VICT)) {
return DELETE_THIS;
}
}
return FALSE;
}
// DELETE_THIS, DELETE_VICT(ch)
int TThing::shootMeBow(TBeing *ch, TBeing *, unsigned int, dirTypeT, int)
{
act("$p isn't a bow!", FALSE, ch, this, 0, TO_CHAR);
return FALSE;
}
int TBeing::unloadBow(const char *arg)
{
TObj *arrow;
TBow *bow = NULL;
TThing *t;
if (!(t = equipment[getPrimaryHold()]) ||
!(bow = dynamic_cast<TBow *>(t)) ||
!bow->getStuff() || !dynamic_cast<TArrow *>(bow->getStuff()))
return FALSE;
arrow = dynamic_cast<TObj *>(bow->getStuff());
--(*arrow);
sendTo("You uncock your bow and take out its arrow!\n\r");
act("$n uncocks $s bow and takes out its arrow!",
TRUE, this, NULL, NULL, TO_ROOM);
*this += *(unequip(getPrimaryHold()));
*this += *arrow;
return TRUE;
}
TThing * TBeing::findArrow(const char *buf, silentTypeT silent) const
{
TThing *arrow;
TQuiver *tQuiver;
int curPos;
TThing *tThing;
arrow = searchLinkedListVis(this, buf, getStuff());
if (!arrow) {
for (curPos = MIN_WEAR; curPos < MAX_WEAR; curPos++) {
if ((tQuiver = dynamic_cast<TQuiver *>(equipment[curPos])) &&
!tQuiver->isClosed()) {
if ((arrow = searchLinkedListVis(this, buf, tQuiver->getStuff()))) {
if (!silent) {
act("You pull $p from $N.",
TRUE, this, arrow, tQuiver, TO_CHAR);
act("$n pulls $p from $N.",
TRUE, this, arrow, tQuiver, TO_ROOM);
}
return arrow;
}
}
}
for (tThing = getStuff(); tThing; tThing = tThing->nextThing) {
if (!(tQuiver = dynamic_cast<TQuiver *>(tThing)) ||
tQuiver->isClosed())
continue;
if (!(arrow = searchLinkedListVis(this, buf, tThing->getStuff())))
continue;
if (!silent) {
act("You pull $p from $N.",
TRUE, this, arrow, tQuiver, TO_CHAR);
}
return arrow;
}
return NULL;
}
return arrow;
}
void TBeing::doBload(const char *arg)
{
char arg1[128],
arg2[128];
TThing *bow;
TThing *arrow;
if (sscanf(arg, "%s %s", arg1, arg2) != 2) {
sendTo("Syntax : bload <bow> <arrow>\n\r");
return;
}
if (heldInPrimHand()) {
if (!isname(arg1, heldInPrimHand()->name)) {
sendTo(COLOR_OBJECTS, fmt("You would have a hard time firing your %s, while holding %s.\n\r") % arg1 % sstring(heldInPrimHand()->getName()).uncap());
return;
} else {
TThing *tObj = heldInPrimHand();
*this += *(unequip(getPrimaryHold()));
//--(*tObj);
//*this += *tObj;
sendTo(COLOR_OBJECTS, fmt("You remove %s to load it.\n\r") %
sstring(tObj->getName()).uncap().c_str());
}
}
if (heldInSecHand()) {
sendTo(COLOR_OBJECTS, fmt("You would have a hard time firing your %s, while holding %s.\n\r") % arg1 % sstring(heldInSecHand()->getName()).uncap());
return;
}
if (!(bow = searchLinkedListVis(this, arg1, getStuff()))) {
sendTo("Syntax : bload <bow> <arrow>\n\r");
return;
}
if(dynamic_cast<TGun *>(bow)){
sendTo("Use gload to load a gun.\n\r");
return;
} else {
arrow = findArrow(arg2, SILENT_NO);
if (arrow)
arrow->bloadBowArrow(this, bow);
else
sendTo(fmt("You seem to have run out of '%s's.\n\r") % arg2);
}
}
void TThing::bloadBowArrow(TBeing *ch, TThing *)
{
ch->sendTo("You can only load your bow with arrows!\n\r");
return;
}
void TThing::bloadArrowBow(TBeing *ch, TArrow *arrow)
{
ch->sendTo("Arrows are usually loaded into bows!\n\r");
return;
}
|
#include "depthai/pipeline/Pipeline.hpp"
#include "depthai/utility/Initialization.hpp"
// std
#include <cassert>
// libraries
#include "spdlog/fmt/fmt.h"
namespace dai {
constexpr OpenVINO::Version PipelineImpl::DEFAULT_OPENVINO_VERSION;
constexpr OpenVINO::Version Pipeline::DEFAULT_OPENVINO_VERSION;
Node::Id PipelineImpl::getNextUniqueId() {
return latestId++;
}
Pipeline::Pipeline() : pimpl(std::make_shared<PipelineImpl>()) {
// Initialize library
initialize();
}
/*
Pipeline::Pipeline(const Pipeline& p){
pimpl = std::make_shared<PipelineImpl>();
// Copy all nodes
pimpl->globalProperties = p.getGlobalProperties();
pimpl->nodes.reserve(p.pimpl->nodes.size());
for(const auto& n : p.pimpl->nodes){
auto clone = n->clone();
clone->parent = std::weak_ptr<PipelineImpl>(pimpl);
pimpl->nodes.push_back(clone);
}
}
*/
Pipeline::Pipeline(const std::shared_ptr<PipelineImpl>& pimpl) {
this->pimpl = pimpl;
}
GlobalProperties Pipeline::getGlobalProperties() const {
return pimpl->globalProperties;
}
/*
void Pipeline::loadAssets(AssetManager& assetManager) {
return pimpl->loadAssets(assetManager);
}
*/
/*
void PipelineImpl::loadAssets() {
// Load assets of nodes
for(const auto& node : nodes){
node->loadAssets(assetManager);
}
// Load assets of pipeline (if any)
// ...
}
*/
std::shared_ptr<const Node> PipelineImpl::getNode(Node::Id id) const {
if(nodeMap.count(id) > 0) {
return nodeMap.at(id);
}
return nullptr;
}
std::shared_ptr<Node> PipelineImpl::getNode(Node::Id id) {
if(nodeMap.count(id) > 0) {
return nodeMap.at(id);
}
return nullptr;
}
std::vector<std::shared_ptr<const Node>> PipelineImpl::getAllNodes() const {
std::vector<std::shared_ptr<const Node>> nodes;
for(const auto& kv : nodeMap) {
nodes.push_back(kv.second);
}
return nodes;
}
std::vector<std::shared_ptr<Node>> PipelineImpl::getAllNodes() {
std::vector<std::shared_ptr<Node>> nodes;
for(const auto& kv : nodeMap) {
nodes.push_back(kv.second);
}
return nodes;
}
void PipelineImpl::serialize(PipelineSchema& schema, Assets& assets, std::vector<std::uint8_t>& assetStorage, OpenVINO::Version& version) const {
// Set schema
schema = getPipelineSchema();
// set assets and generate asset storage
getAllAssets().serialize(assets, assetStorage);
// detect and set openvino version
version = getPipelineOpenVINOVersion();
}
AssetManager PipelineImpl::getAllAssets() const {
AssetManager am = assetManager;
for(const auto& kv : nodeMap) {
const auto& node = kv.second;
// Loop over all nodes and add any assets they have
am.addExisting(node->getAssets());
}
return am;
}
PipelineSchema PipelineImpl::getPipelineSchema() const {
PipelineSchema schema;
schema.globalProperties = globalProperties;
// Loop over nodes, and add them to schema
for(const auto& kv : nodeMap) {
const auto& node = kv.second;
// Create 'node' info
NodeObjInfo info;
info.id = node->id;
info.name = node->getName();
info.properties = node->getProperties();
// Create Io information
auto inputs = node->getInputs();
auto outputs = node->getOutputs();
info.ioInfo.reserve(inputs.size() + outputs.size());
// Add inputs
for(const auto& input : inputs) {
NodeIoInfo io;
io.blocking = input.getBlocking();
io.name = input.name;
switch(input.type) {
case Node::Input::Type::MReceiver:
io.type = NodeIoInfo::Type::MReceiver;
break;
case Node::Input::Type::SReceiver:
io.type = NodeIoInfo::Type::SReceiver;
break;
}
info.ioInfo.push_back(io);
}
// Add outputs
for(const auto& output : outputs) {
NodeIoInfo io;
io.blocking = false;
io.name = output.name;
switch(output.type) {
case Node::Output::Type::MSender:
io.type = NodeIoInfo::Type::MSender;
break;
case Node::Output::Type::SSender:
io.type = NodeIoInfo::Type::SSender;
break;
}
info.ioInfo.push_back(io);
}
// At the end, add the constructed node information to the schema
schema.nodes.push_back(info);
}
// Create 'connections' info
// Loop through connections (output -> input) and add them to schema
for(const auto& kv : nodeConnectionMap) {
const auto& connections = kv.second;
for(const auto& conn : connections) {
NodeConnectionSchema c;
c.node1Id = conn.outputId;
c.node1Output = conn.outputName;
c.node2Id = conn.inputId;
c.node2Input = conn.inputName;
schema.connections.push_back(c);
}
}
return schema;
}
OpenVINO::Version PipelineImpl::getPipelineOpenVINOVersion() const {
// Loop over nodes, and get the required information
tl::optional<OpenVINO::Version> version;
std::string lastNodeNameWithRequiredVersion = "";
Node::Id lastNodeIdWithRequiredVersion = -1;
for(const auto& kv : nodeMap) {
const auto& node = kv.second;
// Check the required openvino version
auto requiredVersion = node->getRequiredOpenVINOVersion();
if(requiredVersion) {
if(forceRequiredOpenVINOVersion) {
// Check that forced openvino version is compatible with this nodes required version
if(!OpenVINO::areVersionsBlobCompatible(*requiredVersion, *forceRequiredOpenVINOVersion)) {
std::string err = fmt::format("Pipeline - '{}' node with id: {}, isn't compatible with forced OpenVINO version", node->getName(), node->id);
throw std::logic_error(err.c_str());
}
} else {
// Keep track of required openvino versions, and make sure that they are all compatible
if(!version) {
version = *requiredVersion;
lastNodeIdWithRequiredVersion = node->id;
lastNodeNameWithRequiredVersion = node->getName();
} else {
// if some node already has an required version, then compare if they are compatible
if(!OpenVINO::areVersionsBlobCompatible(*version, *requiredVersion)) {
// if not compatible, then throw an error
std::string err = fmt::format("Pipeline - OpenVINO version required by '{}' node (id: {}), isn't compatible with '{}' node (id: {})",
lastNodeNameWithRequiredVersion,
lastNodeIdWithRequiredVersion,
node->getName(),
node->id);
throw std::logic_error(err.c_str());
}
}
}
}
}
// After iterating over, set openvinoVersion
OpenVINO::Version openvinoVersion = DEFAULT_OPENVINO_VERSION;
if(forceRequiredOpenVINOVersion) {
// set to forced version
openvinoVersion = *forceRequiredOpenVINOVersion;
} else if(version) {
// set to detected version
openvinoVersion = *version;
}
return openvinoVersion;
}
// Remove node capability
void PipelineImpl::remove(std::shared_ptr<Node> toRemove) {
// Search for this node in 'nodes' vector.
// If found, remove from vector
// First check if node is on this pipeline (and that they are the same)
if(nodeMap.count(toRemove->id) > 0) {
if(nodeMap.at(toRemove->id) == toRemove) {
// its same object, (not same id but from different pipeline)
// Steps to remove
// 1. Iterate and remove this nodes output connections
// 2. Remove this nodes entry in 'nodeConnectionMap'
// 3. Remove node from 'nodeMap'
// 1. Iterate and remove this nodes output connections
for(auto& kv : nodeConnectionMap) {
for(auto& conn : kv.second) {
// check if output belongs to 'toRemove' node
if(conn.outputId == toRemove->id) {
// remove this connection from set
kv.second.erase(conn);
}
}
}
// 2. Remove this nodes entry in 'nodeConnectionMap'
nodeConnectionMap.erase(toRemove->id);
// 3. Remove node from 'nodeMap'
nodeMap.erase(toRemove->id);
}
}
}
bool PipelineImpl::isSamePipeline(const Node::Output& out, const Node::Input& in) {
// Check whether Output 'out' and Input 'in' are on the same pipeline.
// By checking whether their parent nodes are on same pipeline
auto outputPipeline = out.parent.parent.lock();
if(outputPipeline != nullptr) {
return (outputPipeline == in.parent.parent.lock());
}
return false;
}
bool PipelineImpl::canConnect(const Node::Output& out, const Node::Input& in) {
// Check that IoType match up
if(out.type == Node::Output::Type::MSender && in.type == Node::Input::Type::MReceiver) return false;
if(out.type == Node::Output::Type::SSender && in.type == Node::Input::Type::SReceiver) return false;
// Check that datatypes match up
for(const auto& outHierarchy : out.possibleDatatypes) {
for(const auto& inHierarchy : in.possibleDatatypes) {
// Check if datatypes match for current datatype
if(outHierarchy.datatype == inHierarchy.datatype) return true;
// If output can produce descendants
if(outHierarchy.descendants && isDatatypeSubclassOf(outHierarchy.datatype, inHierarchy.datatype)) return true;
// If input allows descendants
if(inHierarchy.descendants && isDatatypeSubclassOf(inHierarchy.datatype, outHierarchy.datatype)) return true;
}
}
// If datatypes don't match up, return false
return false;
}
std::vector<Node::Connection> PipelineImpl::getConnections() const {
std::vector<Node::Connection> connections;
for(const auto& kv : nodeConnectionMap) {
for(const auto& conn : kv.second) {
connections.push_back(conn);
}
}
return connections;
}
void PipelineImpl::link(const Node::Output& out, const Node::Input& in) {
// First check if on same pipeline
if(!isSamePipeline(out, in)) {
throw std::logic_error(fmt::format("Nodes are not on same pipeline or one of nodes parent pipeline doesn't exists anymore"));
}
if(!canConnect(out, in)) {
throw std::runtime_error(fmt::format("Cannot link '{}.{}' to '{}.{}'", out.parent.getName(), out.name, in.parent.getName(), in.name));
}
// Create 'Connection' object between 'out' and 'in'
Node::Connection connection(out, in);
// Check if connection was already made - the following is possible as operator[] constructs the underlying set if it doesn't exist.
if(nodeConnectionMap[in.parent.id].count(connection) > 0) {
// this means a connection was already made.
throw std::logic_error(fmt::format("'{}.{}' already linked to '{}.{}'", out.parent.getName(), out.name, in.parent.getName(), in.name));
}
// Otherwise all is set to add a new connection into nodeConnectionMap[in.parent.id]
nodeConnectionMap[in.parent.id].insert(connection);
}
void PipelineImpl::unlink(const Node::Output& out, const Node::Input& in) {
// First check if on same pipeline
if(!isSamePipeline(out, in)) {
throw std::logic_error(fmt::format("Nodes are not on same pipeline or one of nodes parent pipeline doesn't exists anymore"));
}
// Create 'Connection' object
Node::Connection connection(out, in);
// Check if not connected (connection object doesn't exist in nodeConnectionMap)
if(nodeConnectionMap[in.parent.id].count(connection) <= 0) {
// not connected
throw std::logic_error(fmt::format("'{}.{}' not linked to '{}.{}'", out.parent.getName(), out.name, in.parent.getName(), in.name));
}
// Otherwise if exists, remove this connection
nodeConnectionMap[in.parent.id].erase(connection);
}
} // namespace dai
Pipeline::remove iterator invalidation hotfix
#include "depthai/pipeline/Pipeline.hpp"
#include "depthai/utility/Initialization.hpp"
// std
#include <cassert>
// libraries
#include "spdlog/fmt/fmt.h"
namespace dai {
constexpr OpenVINO::Version PipelineImpl::DEFAULT_OPENVINO_VERSION;
constexpr OpenVINO::Version Pipeline::DEFAULT_OPENVINO_VERSION;
Node::Id PipelineImpl::getNextUniqueId() {
return latestId++;
}
Pipeline::Pipeline() : pimpl(std::make_shared<PipelineImpl>()) {
// Initialize library
initialize();
}
/*
Pipeline::Pipeline(const Pipeline& p){
pimpl = std::make_shared<PipelineImpl>();
// Copy all nodes
pimpl->globalProperties = p.getGlobalProperties();
pimpl->nodes.reserve(p.pimpl->nodes.size());
for(const auto& n : p.pimpl->nodes){
auto clone = n->clone();
clone->parent = std::weak_ptr<PipelineImpl>(pimpl);
pimpl->nodes.push_back(clone);
}
}
*/
Pipeline::Pipeline(const std::shared_ptr<PipelineImpl>& pimpl) {
this->pimpl = pimpl;
}
GlobalProperties Pipeline::getGlobalProperties() const {
return pimpl->globalProperties;
}
/*
void Pipeline::loadAssets(AssetManager& assetManager) {
return pimpl->loadAssets(assetManager);
}
*/
/*
void PipelineImpl::loadAssets() {
// Load assets of nodes
for(const auto& node : nodes){
node->loadAssets(assetManager);
}
// Load assets of pipeline (if any)
// ...
}
*/
std::shared_ptr<const Node> PipelineImpl::getNode(Node::Id id) const {
if(nodeMap.count(id) > 0) {
return nodeMap.at(id);
}
return nullptr;
}
std::shared_ptr<Node> PipelineImpl::getNode(Node::Id id) {
if(nodeMap.count(id) > 0) {
return nodeMap.at(id);
}
return nullptr;
}
std::vector<std::shared_ptr<const Node>> PipelineImpl::getAllNodes() const {
std::vector<std::shared_ptr<const Node>> nodes;
for(const auto& kv : nodeMap) {
nodes.push_back(kv.second);
}
return nodes;
}
std::vector<std::shared_ptr<Node>> PipelineImpl::getAllNodes() {
std::vector<std::shared_ptr<Node>> nodes;
for(const auto& kv : nodeMap) {
nodes.push_back(kv.second);
}
return nodes;
}
void PipelineImpl::serialize(PipelineSchema& schema, Assets& assets, std::vector<std::uint8_t>& assetStorage, OpenVINO::Version& version) const {
// Set schema
schema = getPipelineSchema();
// set assets and generate asset storage
getAllAssets().serialize(assets, assetStorage);
// detect and set openvino version
version = getPipelineOpenVINOVersion();
}
AssetManager PipelineImpl::getAllAssets() const {
AssetManager am = assetManager;
for(const auto& kv : nodeMap) {
const auto& node = kv.second;
// Loop over all nodes and add any assets they have
am.addExisting(node->getAssets());
}
return am;
}
PipelineSchema PipelineImpl::getPipelineSchema() const {
PipelineSchema schema;
schema.globalProperties = globalProperties;
// Loop over nodes, and add them to schema
for(const auto& kv : nodeMap) {
const auto& node = kv.second;
// Create 'node' info
NodeObjInfo info;
info.id = node->id;
info.name = node->getName();
info.properties = node->getProperties();
// Create Io information
auto inputs = node->getInputs();
auto outputs = node->getOutputs();
info.ioInfo.reserve(inputs.size() + outputs.size());
// Add inputs
for(const auto& input : inputs) {
NodeIoInfo io;
io.blocking = input.getBlocking();
io.name = input.name;
switch(input.type) {
case Node::Input::Type::MReceiver:
io.type = NodeIoInfo::Type::MReceiver;
break;
case Node::Input::Type::SReceiver:
io.type = NodeIoInfo::Type::SReceiver;
break;
}
info.ioInfo.push_back(io);
}
// Add outputs
for(const auto& output : outputs) {
NodeIoInfo io;
io.blocking = false;
io.name = output.name;
switch(output.type) {
case Node::Output::Type::MSender:
io.type = NodeIoInfo::Type::MSender;
break;
case Node::Output::Type::SSender:
io.type = NodeIoInfo::Type::SSender;
break;
}
info.ioInfo.push_back(io);
}
// At the end, add the constructed node information to the schema
schema.nodes.push_back(info);
}
// Create 'connections' info
// Loop through connections (output -> input) and add them to schema
for(const auto& kv : nodeConnectionMap) {
const auto& connections = kv.second;
for(const auto& conn : connections) {
NodeConnectionSchema c;
c.node1Id = conn.outputId;
c.node1Output = conn.outputName;
c.node2Id = conn.inputId;
c.node2Input = conn.inputName;
schema.connections.push_back(c);
}
}
return schema;
}
OpenVINO::Version PipelineImpl::getPipelineOpenVINOVersion() const {
// Loop over nodes, and get the required information
tl::optional<OpenVINO::Version> version;
std::string lastNodeNameWithRequiredVersion = "";
Node::Id lastNodeIdWithRequiredVersion = -1;
for(const auto& kv : nodeMap) {
const auto& node = kv.second;
// Check the required openvino version
auto requiredVersion = node->getRequiredOpenVINOVersion();
if(requiredVersion) {
if(forceRequiredOpenVINOVersion) {
// Check that forced openvino version is compatible with this nodes required version
if(!OpenVINO::areVersionsBlobCompatible(*requiredVersion, *forceRequiredOpenVINOVersion)) {
std::string err = fmt::format("Pipeline - '{}' node with id: {}, isn't compatible with forced OpenVINO version", node->getName(), node->id);
throw std::logic_error(err.c_str());
}
} else {
// Keep track of required openvino versions, and make sure that they are all compatible
if(!version) {
version = *requiredVersion;
lastNodeIdWithRequiredVersion = node->id;
lastNodeNameWithRequiredVersion = node->getName();
} else {
// if some node already has an required version, then compare if they are compatible
if(!OpenVINO::areVersionsBlobCompatible(*version, *requiredVersion)) {
// if not compatible, then throw an error
std::string err = fmt::format("Pipeline - OpenVINO version required by '{}' node (id: {}), isn't compatible with '{}' node (id: {})",
lastNodeNameWithRequiredVersion,
lastNodeIdWithRequiredVersion,
node->getName(),
node->id);
throw std::logic_error(err.c_str());
}
}
}
}
}
// After iterating over, set openvinoVersion
OpenVINO::Version openvinoVersion = DEFAULT_OPENVINO_VERSION;
if(forceRequiredOpenVINOVersion) {
// set to forced version
openvinoVersion = *forceRequiredOpenVINOVersion;
} else if(version) {
// set to detected version
openvinoVersion = *version;
}
return openvinoVersion;
}
// Remove node capability
void PipelineImpl::remove(std::shared_ptr<Node> toRemove) {
// Search for this node in 'nodes' vector.
// If found, remove from vector
// First check if node is on this pipeline (and that they are the same)
if(nodeMap.count(toRemove->id) > 0) {
if(nodeMap.at(toRemove->id) == toRemove) {
// its same object, (not same id but from different pipeline)
// Steps to remove
// 1. Iterate and remove this nodes output connections
// 2. Remove this nodes entry in 'nodeConnectionMap'
// 3. Remove node from 'nodeMap'
// 1. Iterate and remove this nodes output connections
for(auto& kv : nodeConnectionMap) {
for (auto it = kv.second.begin(); it != kv.second.end();) {
// check if output belongs to 'toRemove' node
if(it->outputId == toRemove->id) {
// remove this connection from set
it = kv.second.erase(it);
} else {
++it;
}
}
}
// 2. Remove this nodes entry in 'nodeConnectionMap'
nodeConnectionMap.erase(toRemove->id);
// 3. Remove node from 'nodeMap'
nodeMap.erase(toRemove->id);
}
}
}
bool PipelineImpl::isSamePipeline(const Node::Output& out, const Node::Input& in) {
// Check whether Output 'out' and Input 'in' are on the same pipeline.
// By checking whether their parent nodes are on same pipeline
auto outputPipeline = out.parent.parent.lock();
if(outputPipeline != nullptr) {
return (outputPipeline == in.parent.parent.lock());
}
return false;
}
bool PipelineImpl::canConnect(const Node::Output& out, const Node::Input& in) {
// Check that IoType match up
if(out.type == Node::Output::Type::MSender && in.type == Node::Input::Type::MReceiver) return false;
if(out.type == Node::Output::Type::SSender && in.type == Node::Input::Type::SReceiver) return false;
// Check that datatypes match up
for(const auto& outHierarchy : out.possibleDatatypes) {
for(const auto& inHierarchy : in.possibleDatatypes) {
// Check if datatypes match for current datatype
if(outHierarchy.datatype == inHierarchy.datatype) return true;
// If output can produce descendants
if(outHierarchy.descendants && isDatatypeSubclassOf(outHierarchy.datatype, inHierarchy.datatype)) return true;
// If input allows descendants
if(inHierarchy.descendants && isDatatypeSubclassOf(inHierarchy.datatype, outHierarchy.datatype)) return true;
}
}
// If datatypes don't match up, return false
return false;
}
std::vector<Node::Connection> PipelineImpl::getConnections() const {
std::vector<Node::Connection> connections;
for(const auto& kv : nodeConnectionMap) {
for(const auto& conn : kv.second) {
connections.push_back(conn);
}
}
return connections;
}
void PipelineImpl::link(const Node::Output& out, const Node::Input& in) {
// First check if on same pipeline
if(!isSamePipeline(out, in)) {
throw std::logic_error(fmt::format("Nodes are not on same pipeline or one of nodes parent pipeline doesn't exists anymore"));
}
if(!canConnect(out, in)) {
throw std::runtime_error(fmt::format("Cannot link '{}.{}' to '{}.{}'", out.parent.getName(), out.name, in.parent.getName(), in.name));
}
// Create 'Connection' object between 'out' and 'in'
Node::Connection connection(out, in);
// Check if connection was already made - the following is possible as operator[] constructs the underlying set if it doesn't exist.
if(nodeConnectionMap[in.parent.id].count(connection) > 0) {
// this means a connection was already made.
throw std::logic_error(fmt::format("'{}.{}' already linked to '{}.{}'", out.parent.getName(), out.name, in.parent.getName(), in.name));
}
// Otherwise all is set to add a new connection into nodeConnectionMap[in.parent.id]
nodeConnectionMap[in.parent.id].insert(connection);
}
void PipelineImpl::unlink(const Node::Output& out, const Node::Input& in) {
// First check if on same pipeline
if(!isSamePipeline(out, in)) {
throw std::logic_error(fmt::format("Nodes are not on same pipeline or one of nodes parent pipeline doesn't exists anymore"));
}
// Create 'Connection' object
Node::Connection connection(out, in);
// Check if not connected (connection object doesn't exist in nodeConnectionMap)
if(nodeConnectionMap[in.parent.id].count(connection) <= 0) {
// not connected
throw std::logic_error(fmt::format("'{}.{}' not linked to '{}.{}'", out.parent.getName(), out.name, in.parent.getName(), in.name));
}
// Otherwise if exists, remove this connection
nodeConnectionMap[in.parent.id].erase(connection);
}
} // namespace dai
|
#include "testsettings.hpp"
#ifdef TEST_TABLE
#include <algorithm>
#include <limits>
#include <string>
#include <fstream>
#include <ostream>
#include <realm.hpp>
#include <realm/lang_bind_helper.hpp>
#include <realm/util/buffer.hpp>
#include "util/misc.hpp"
#include "test.hpp"
using namespace realm;
using namespace realm::util;
using namespace realm::test_util;
using unit_test::TestResults;
// Test independence and thread-safety
// -----------------------------------
//
// All tests must be thread safe and independent of each other. This
// is required because it allows for both shuffling of the execution
// order and for parallelized testing.
//
// In particular, avoid using std::rand() since it is not guaranteed
// to be thread safe. Instead use the API offered in
// `test/util/random.hpp`.
//
// All files created in tests must use the TEST_PATH macro (or one of
// its friends) to obtain a suitable file system path. See
// `test/util/test_path.hpp`.
//
//
// Debugging and the ONLY() macro
// ------------------------------
//
// A simple way of disabling all tests except one called `Foo`, is to
// replace TEST(Foo) with ONLY(Foo) and then recompile and rerun the
// test suite. Note that you can also use filtering by setting the
// environment varible `UNITTEST_FILTER`. See `README.md` for more on
// this.
//
// Another way to debug a particular test, is to copy that test into
// `experiments/testcase.cpp` and then run `sh build.sh
// check-testcase` (or one of its friends) from the command line.
namespace {
REALM_TABLE_2(TupleTableType,
first, Int,
second, String)
} // anonymous namespace
#ifdef JAVA_MANY_COLUMNS_CRASH
REALM_TABLE_3(SubtableType,
year, Int,
daysSinceLastVisit, Int,
conceptId, String)
REALM_TABLE_7(MainTableType,
patientId, String,
gender, Int,
ethnicity, Int,
yearOfBirth, Int,
yearOfDeath, Int,
zipCode, String,
events, Subtable<SubtableType>)
TEST(Table_ManyColumnsCrash2)
{
// Trying to reproduce Java crash.
for (int a = 0; a < 10; a++)
{
Group group;
MainTableType::Ref mainTable = group.add_table<MainTableType>("PatientTable");
TableRef dynPatientTable = group.add_table("PatientTable");
dynPatientTable->add_empty_row();
for (int counter = 0; counter < 20000; counter++)
{
#if 0
// Add row to subtable through typed interface
SubtableType::Ref subtable = mainTable[0].events->get_table_ref();
REALM_ASSERT(subtable->is_attached());
subtable->add(0, 0, "");
REALM_ASSERT(subtable->is_attached());
#else
// Add row to subtable through dynamic interface. This mimics Java closest
TableRef subtable2 = dynPatientTable->get_subtable(6, 0);
REALM_ASSERT(subtable2->is_attached());
size_t subrow = subtable2->add_empty_row();
REALM_ASSERT(subtable2->is_attached());
#endif
if((counter % 1000) == 0){
// std::cerr << counter << "\n";
}
}
}
}
#endif // JAVA_MANY_COLUMNS_CRASH
TEST(Table_Null)
{
{
// Check that add_empty_row() adds NULL string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name", true); // nullable = true
table->add_empty_row();
CHECK(table->get_string(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
table->add_empty_row();
CHECK(!table->get_string(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_string(0, 0, realm::null()), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds null integer as default
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "name", true /*nullable*/);
table->add_empty_row();
CHECK(table->is_null(0, 0));
}
{
// Check that add_empty_row() adds 0 integer as default.
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Int, "name");
table->add_empty_row();
CHECK(!table->is_null(0, 0));
CHECK_EQUAL(0, table->get_int(0, 0));
// Check that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_null(0, 0), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds NULL binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name", true /*nullable*/);
table->add_empty_row();
CHECK(table->get_binary(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name");
table->add_empty_row();
CHECK(!table->get_binary(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_THROW_ANY(table->set_binary(0, 0, BinaryData()));
}
}
TEST(Table_DeleteCrash)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
table->add_column(type_Int, "age");
table->add_empty_row(3);
table->set_string(0, 0, "Alice");
table->set_int(1, 0, 27);
table->set_string(0, 1, "Bob");
table->set_int(1, 1, 50);
table->set_string(0, 2, "Peter");
table->set_int(1, 2, 44);
table->remove(0);
table->remove(1);
}
TEST(Table_OptimizeCrash)
{
// This will crash at the .add() method
TupleTableType ttt;
ttt.optimize();
ttt.column().second.add_search_index();
ttt.clear();
ttt.add(1, "AA");
}
TEST(Table_1)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Int, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_int(1, ndx, 10);
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(10, table.get_int(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_int(0, i, 2*i);
table.set_int(1, i, 20*i);
}
for (size_t i = ndx; i < 7; ++i) {
const int64_t v1 = 2 * i;
const int64_t v2 = 20 * i;
CHECK_EQUAL(v1, table.get_int(0, i));
CHECK_EQUAL(v2, table.get_int(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_ColumnNameTooLong)
{
Group group;
TableRef table = group.add_table("foo");
const size_t buf_size = 64;
std::unique_ptr<char[]> buf(new char[buf_size]);
CHECK_LOGIC_ERROR(table->add_column(type_Int, StringData(buf.get(), buf_size)),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column(0, type_Int, StringData(buf.get(), buf_size)),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->add_column_link(type_Link,
StringData(buf.get(), buf_size),
*table),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column_link(0, type_Link,
StringData(buf.get(), buf_size),
*table),
LogicError::column_name_too_long);
table->add_column(type_Int, StringData(buf.get(), buf_size - 1));
table->insert_column(0, type_Int, StringData(buf.get(), buf_size - 1));
table->add_column_link(type_Link, StringData(buf.get(), buf_size - 1), *table);
table->insert_column_link(0, type_Link, StringData(buf.get(), buf_size - 1), *table);
}
TEST(Table_StringOrBinaryTooBig)
{
Table table;
table.add_column(type_String, "s");
table.add_column(type_Binary, "b");
table.add_column(type_Mixed, "m1");
table.add_column(type_Mixed, "m2");
table.add_empty_row();
table.set_string(0, 0, "01234567");
size_t large_bin_size = 0xFFFFF1;
size_t large_str_size = 0xFFFFF0; // null-terminate reduces max size by 1
std::unique_ptr<char[]> large_buf(new char[large_bin_size]);
CHECK_LOGIC_ERROR(table.set_string(0, 0, StringData(large_buf.get(), large_str_size)),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size)),
LogicError::binary_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size))),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size))),
LogicError::binary_too_big);
table.set_string(0, 0, StringData(large_buf.get(), large_str_size - 1));
table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size - 1));
table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size - 1)));
table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size - 1)));
}
TEST(Table_Floats)
{
Table table;
table.add_column(type_Float, "first");
table.add_column(type_Double, "second");
CHECK_EQUAL(type_Float, table.get_column_type(0));
CHECK_EQUAL(type_Double, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_float(0, ndx, float(1.12));
table.set_double(1, ndx, double(102.13));
CHECK_EQUAL(float(1.12), table.get_float(0, ndx));
CHECK_EQUAL(double(102.13), table.get_double(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_float(0, i, float(1.12) + 100*i);
table.set_double(1, i, double(102.13)*200*i);
}
for (size_t i = ndx; i < 7; ++i) {
const float v1 = float(1.12) + 100*i;
const double v2 = double(102.13)*200*i;
CHECK_EQUAL(v1, table.get_float(0, i));
CHECK_EQUAL(v2, table.get_double(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
REALM_TABLE_4(TestTable,
first, Int,
second, Int,
third, Bool,
fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_2)
{
TestTable table;
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL(0, r.first);
CHECK_EQUAL(10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL(Wed, r.fourth);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_3)
{
TestTable table;
for (size_t i = 0; i < 100; ++i) {
table.add(0, 10, true, Wed);
}
// Test column searching
CHECK_EQUAL(size_t(0), table.column().first.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().first.find_first(1));
CHECK_EQUAL(size_t(0), table.column().second.find_first(10));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(100));
CHECK_EQUAL(size_t(0), table.column().third.find_first(true));
CHECK_EQUAL(size_t(-1), table.column().third.find_first(false));
CHECK_EQUAL(size_t(0) , table.column().fourth.find_first(Wed));
CHECK_EQUAL(size_t(-1), table.column().fourth.find_first(Mon));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableEnum,
first, Enum<Days>,
second, String)
} // anonymous namespace
TEST(Table_4)
{
TestTableEnum table;
table.add(Mon, "Hello");
table.add(Mon, "HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello");
const TestTableEnum::Cursor r = table.back(); // last item
CHECK_EQUAL(Mon, r.first);
CHECK_EQUAL("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello", r.second);
// Test string column searching
CHECK_EQUAL(size_t(1), table.column().second.find_first("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello"));
CHECK_EQUAL(size_t(-1), table.column().second.find_first("Foo"));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableFloats,
first, Float,
second, Double)
} // anonymous namespace
TEST(Table_Float2)
{
TestTableFloats table;
table.add(1.1f, 2.2);
table.add(1.1f, 2.2);
const TestTableFloats::Cursor r = table.back(); // last item
CHECK_EQUAL(1.1f, r.first);
CHECK_EQUAL(2.2, r.second);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Delete)
{
TestTable table;
for (size_t i = 0; i < 10; ++i) {
table.add(0, i, true, Wed);
}
table.remove(0);
table.remove(4);
table.remove(7);
CHECK_EQUAL(1, table[0].second);
CHECK_EQUAL(2, table[1].second);
CHECK_EQUAL(3, table[2].second);
CHECK_EQUAL(4, table[3].second);
CHECK_EQUAL(6, table[4].second);
CHECK_EQUAL(7, table[5].second);
CHECK_EQUAL(8, table[6].second);
#ifdef REALM_DEBUG
table.verify();
#endif
// Delete all items one at a time
for (size_t i = 0; i < 7; ++i) {
table.remove(0);
}
CHECK(table.is_empty());
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_GetName)
{
// Freestanding tables have no names
{
Table table;
CHECK_EQUAL("", table.get_name());
}
// ... regardless of how they are created
{
TableRef table = Table::create();
CHECK_EQUAL("", table->get_name());
}
// Direct members of groups do have names
{
Group group;
TableRef table = group.add_table("table");
CHECK_EQUAL("table", table->get_name());
}
{
Group group;
TableRef foo = group.add_table("foo");
TableRef bar = group.add_table("bar");
CHECK_EQUAL("foo", foo->get_name());
CHECK_EQUAL("bar", bar->get_name());
}
// Subtables should never have names
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "sub", &subdesc);
table.add_empty_row();
TableRef subtab = table.get_subtable(0,0);
CHECK_EQUAL("", table.get_name());
CHECK_EQUAL("", subtab->get_name());
}
// ... not even when the parent is a member of a group
{
Group group;
TableRef table = group.add_table("table");
DescriptorRef subdesc;
table->add_column(type_Table, "sub", &subdesc);
table->add_empty_row();
TableRef subtab = table->get_subtable(0,0);
CHECK_EQUAL("table", table->get_name());
CHECK_EQUAL("", subtab->get_name());
}
}
namespace {
void setup_multi_table(Table& table, size_t rows, size_t sub_rows,
bool fixed_subtab_sizes = false)
{
// Create table with all column types
{
DescriptorRef sub1;
table.add_column(type_Int, "int"); // 0
table.add_column(type_Bool, "bool"); // 1
table.add_column(type_DateTime, "date"); // 2
table.add_column(type_Float, "float"); // 3
table.add_column(type_Double, "double"); // 4
table.add_column(type_String, "string"); // 5
table.add_column(type_String, "string_long"); // 6
table.add_column(type_String, "string_big_blobs"); // 7
table.add_column(type_String, "string_enum"); // 8 - becomes StringEnumColumn
table.add_column(type_Binary, "binary"); // 9
table.add_column(type_Table, "tables", &sub1); // 10
table.add_column(type_Mixed, "mixed"); // 11
table.add_column(type_Int, "int_null", true); // 12, nullable = true
sub1->add_column(type_Int, "sub_first");
sub1->add_column(type_String, "sub_second");
}
table.add_empty_row(rows);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
table.set_int(0, i, int64_t(i*sign));
if (i % 4 == 0) {
table.set_null(12, i);
}
else {
table.set_int(12, i, int64_t(i*sign));
}
}
for (size_t i = 0; i < rows; ++i)
table.set_bool(1, i, (i % 2 ? true : false));
for (size_t i = 0; i < rows; ++i)
table.set_datetime(2, i, 12345);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
table.set_float(3, i, 123.456f*sign);
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
table.set_double(4, i, 9876.54321*sign);
}
std::vector<std::string> strings;
for (size_t i = 0; i < rows; ++i) {
std::stringstream out;
out << "string" << i;
strings.push_back(out.str());
}
for (size_t i = 0; i < rows; ++i)
table.set_string(5, i, strings[i]);
for (size_t i = 0; i < rows; ++i)
table.set_string(6, i, strings[i] + " very long string.........");
for (size_t i = 0; i < rows; ++i) {
switch (i % 2) {
case 0: {
std::string s = strings[i];
s += " very long string.........";
for (int j = 0; j != 4; ++j)
s += " big blobs big blobs big blobs"; // +30
table.set_string(7, i, s);
break;
}
case 1:
table.set_string(7, i, "");
break;
}
}
for (size_t i = 0; i < rows; ++i) {
switch (i % 3) {
case 0:
table.set_string(8, i, "enum1");
break;
case 1:
table.set_string(8, i, "enum2");
break;
case 2:
table.set_string(8, i, "enum3");
break;
}
}
for (size_t i = 0; i < rows; ++i)
table.set_binary(9, i, BinaryData("binary", 7));
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
size_t n = sub_rows;
if (!fixed_subtab_sizes)
n += i;
for (size_t j = 0; j != n; ++j) {
TableRef subtable = table.get_subtable(10, i);
int64_t val = -123+i*j*1234*sign;
subtable->insert_empty_row(j);
subtable->set_int(0, j, val);
subtable->set_string(1, j, "sub");
}
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
switch (i % 8) {
case 0:
table.set_mixed(11, i, false);
break;
case 1:
table.set_mixed(11, i, int64_t(i*i*sign));
break;
case 2:
table.set_mixed(11, i, "string");
break;
case 3:
table.set_mixed(11, i, DateTime(123456789));
break;
case 4:
table.set_mixed(11, i, BinaryData("binary", 7));
break;
case 5: {
// Add subtable to mixed column
// We can first set schema and contents when the entire
// row has been inserted
table.set_mixed(11, i, Mixed::subtable_tag());
TableRef subtable = table.get_subtable(11, i);
subtable->add_column(type_Int, "first");
subtable->add_column(type_String, "second");
for (size_t j = 0; j != 2; ++j) {
subtable->insert_empty_row(j);
subtable->set_int(0, j, i*i*j*sign);
subtable->set_string(1, j, "mixed sub");
}
break;
}
case 6:
table.set_mixed(11, i, float(123.1*i*sign));
break;
case 7:
table.set_mixed(11, i, double(987.65*i*sign));
break;
}
}
// We also want a StringEnumColumn
table.optimize();
}
} // anonymous namespace
TEST(Table_LowLevelCopy)
{
Table table;
setup_multi_table(table, 15, 2);
#ifdef REALM_DEBUG
table.verify();
#endif
Table table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TableRef table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_HighLevelCopy)
{
TestTable table;
table.add(10, 120, false, Mon);
table.add(12, 100, true, Tue);
#ifdef REALM_DEBUG
table.verify();
#endif
TestTable table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TestTable::Ref table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_DeleteAllTypes)
{
Table table;
setup_multi_table(table, 15, 2);
// Test Deletes
table.remove(14);
table.remove(0);
table.remove(5);
CHECK_EQUAL(12, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
// Test Clear
table.clear();
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
// Triggers a bug that would make Realm crash if you run optimize() followed by add_search_index()
TEST(Table_Optimize_SetIndex_Crash)
{
Table table;
table.add_column(type_String, "first");
table.add_empty_row(3);
table.set_string(0, 0, "string0");
table.set_string(0, 1, "string1");
table.set_string(0, 2, "string1");
table.optimize();
CHECK_NOT_EQUAL(0, table.get_descriptor()->get_num_unique_values(0));
table.set_string(0, 2, "string2");
table.add_search_index(0);
table.move_last_over(1);
table.move_last_over(1);
}
TEST(Table_MoveAllTypes)
{
Random random(random_int<unsigned long>()); // Seed from slow global generator
Table table;
setup_multi_table(table, 15, 2);
table.add_search_index(6);
while (!table.is_empty()) {
size_t size = table.size();
size_t target_row_ndx = random.draw_int_mod(size);
table.move_last_over(target_row_ndx);
table.verify();
}
}
TEST(Table_DegenerateSubtableSearchAndAggregate)
{
Table parent;
// Add all column types
{
DescriptorRef sub_1, sub_2;
parent.add_column(type_Table, "child", &sub_1);
sub_1->add_column(type_Int, "int"); // 0
sub_1->add_column(type_Bool, "bool"); // 1
sub_1->add_column(type_Float, "float"); // 2
sub_1->add_column(type_Double, "double"); // 3
sub_1->add_column(type_DateTime, "date"); // 4
sub_1->add_column(type_String, "string"); // 5
sub_1->add_column(type_Binary, "binary"); // 6
sub_1->add_column(type_Table, "table", &sub_2); // 7
sub_1->add_column(type_Mixed, "mixed"); // 8
sub_1->add_column(type_Int, "int_null", nullptr, true); // 9, nullable = true
sub_2->add_column(type_Int, "i");
}
parent.add_empty_row(); // Create a degenerate subtable
ConstTableRef degen_child = parent.get_subtable(0,0); // NOTE: Constness is essential here!!!
CHECK_EQUAL(0, degen_child->size());
CHECK_EQUAL(10, degen_child->get_column_count());
// Searching:
CHECK_LOGIC_ERROR(degen_child->find_pkey_string(""), LogicError::no_primary_key);
// CHECK_EQUAL(0, degen_child->distinct(0).size()); // needs index but you cannot set index on ConstTableRef
CHECK_EQUAL(0, degen_child->get_sorted_view(0).size());
CHECK_EQUAL(not_found, degen_child->find_first_int(0, 0));
CHECK_EQUAL(not_found, degen_child->find_first_bool(1, false));
CHECK_EQUAL(not_found, degen_child->find_first_float(2, 0));
CHECK_EQUAL(not_found, degen_child->find_first_double(3, 0));
CHECK_EQUAL(not_found, degen_child->find_first_datetime(4, DateTime()));
CHECK_EQUAL(not_found, degen_child->find_first_string(5, StringData("")));
// CHECK_EQUAL(not_found, degen_child->find_first_binary(6, BinaryData())); // Exists but not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->find_all_int(0, 0).size());
CHECK_EQUAL(0, degen_child->find_all_bool(1, false).size());
CHECK_EQUAL(0, degen_child->find_all_float(2, 0).size());
CHECK_EQUAL(0, degen_child->find_all_double(3, 0).size());
CHECK_EQUAL(0, degen_child->find_all_datetime(4, DateTime()).size());
CHECK_EQUAL(0, degen_child->find_all_string(5, StringData("")).size());
// CHECK_EQUAL(0, degen_child->find_all_binary(6, BinaryData()).size()); // Exists but not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_subtable(7, subtab).size()); // Not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_mixed(8, Mixed()).size()); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->lower_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->lower_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->lower_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->lower_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->lower_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->upper_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->upper_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->upper_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->upper_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->upper_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_mixed(8, Mixed())); // Not yet implemented
// Aggregates:
CHECK_EQUAL(0, degen_child->count_int(0, 0));
// CHECK_EQUAL(0, degen_child->count_bool(1, false)); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_float(2, 0));
CHECK_EQUAL(0, degen_child->count_double(3, 0));
// CHECK_EQUAL(0, degen_child->count_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->count_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->minimum_int(0));
CHECK_EQUAL(0, degen_child->minimum_float(2));
CHECK_EQUAL(0, degen_child->minimum_double(3));
CHECK_EQUAL(0, degen_child->minimum_datetime(4));
CHECK_EQUAL(0, degen_child->maximum_int(0));
CHECK_EQUAL(0, degen_child->maximum_float(2));
CHECK_EQUAL(0, degen_child->maximum_double(3));
CHECK_EQUAL(0, degen_child->maximum_datetime(4));
CHECK_EQUAL(0, degen_child->sum_int(0));
CHECK_EQUAL(0, degen_child->sum_float(2));
CHECK_EQUAL(0, degen_child->sum_double(3));
CHECK_EQUAL(0, degen_child->average_int(0));
CHECK_EQUAL(0, degen_child->average_float(2));
CHECK_EQUAL(0, degen_child->average_double(3));
// Queries:
CHECK_EQUAL(not_found, degen_child->where().equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(1, false).find());
CHECK_EQUAL(not_found, degen_child->where().equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().equal_datetime(4, DateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().equal(8, Mixed()).find()); // Not yet implemented
CHECK_EQUAL(not_found, degen_child->where().not_equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal_datetime(4, DateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().not_equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().not_equal(8, Mixed()).find()); // Not yet implemented
TableView v = degen_child->where().equal(0, int64_t()).find_all();
CHECK_EQUAL(0, v.size());
v = degen_child->where().equal(5, "hello").find_all();
CHECK_EQUAL(0, v.size());
size_t r = degen_child->where().equal(5, "hello").count();
CHECK_EQUAL(0, r);
r = degen_child->where().equal(5, "hello").remove();
CHECK_EQUAL(0, r);
size_t res;
degen_child->where().equal(5, "hello").average_int(0, &res);
CHECK_EQUAL(0, res);
}
TEST(Table_Range)
{
Table table;
table.add_column(type_Int, "int");
table.add_empty_row(100);
for (size_t i = 0 ; i < 100; ++i)
table.set_int(0, i, i);
TableView tv = table.get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i < tv.size(); ++i)
CHECK_EQUAL(int64_t(i+10), tv.get_int(0, i));
}
TEST(Table_RangeConst)
{
Group group;
{
TableRef table = group.add_table("test");
table->add_column(type_Int, "int");
table->add_empty_row(100);
for (int i = 0 ; i < 100; ++i)
table->set_int(0, i, i);
}
ConstTableRef ctable = group.get_table("test");
ConstTableView tv = ctable->get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i<tv.size(); ++i)
CHECK_EQUAL(int64_t(i+10), tv.get_int(0, i));
}
// enable to generate testfiles for to_string below
#define GENERATE 0
TEST(Table_ToString)
{
Table table;
setup_multi_table(table, 15, 6);
std::stringstream ss;
table.to_string(ss);
const std::string result = ss.str();
std::string file_name = get_test_resource_path();
file_name += "expect_string.txt";
#if GENERATE // enable to generate testfile - check it manually
std::ofstream test_file(file_name.c_str(), std::ios::out);
test_file << result;
std::cerr << "to_string() test:\n" << result << std::endl;
#else
std::ifstream test_file(file_name.c_str(), std::ios::in);
CHECK(!test_file.fail());
std::string expected;
expected.assign( std::istreambuf_iterator<char>(test_file),
std::istreambuf_iterator<char>() );
bool test_ok = test_util::equal_without_cr(result, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
TEST_PATH(path);
File out(path, File::mode_Write);
out.write(result);
std::cerr << "\n error result in '" << std::string(path) << "'\n";
}
#endif
}
/* DISABLED BECAUSE IT FAILS - A PULL REQUEST WILL BE MADE WHERE IT IS REENABLED!
TEST(Table_RowToString)
{
// Create table with all column types
Table table;
setup_multi_table(table, 2, 2);
std::stringstream ss;
table.row_to_string(1, ss);
const std::string row_str = ss.str();
#if 0
std::ofstream test_file("row_to_string.txt", ios::out);
test_file << row_str;
#endif
std::string expected = " int bool date float double string string_long string_enum binary mixed tables\n"
"1: -1 true 1970-01-01 03:25:45 -1.234560e+002 -9.876543e+003 string1 string1 very long st... enum2 7 bytes -1 [3]\n";
bool test_ok = test_util::equal_without_cr(row_str, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
std::cerr << "row_to_string() failed\n"
<< "Expected: " << expected << "\n"
<< "Got : " << row_str << std::endl;
}
}
TEST(Table_FindInt)
{
TestTable table;
for (int i = 1000; i >= 0; --i) {
table.add(0, i, true, Wed);
}
CHECK_EQUAL(size_t(0), table.column().second.find_first(1000));
CHECK_EQUAL(size_t(1000), table.column().second.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(1001));
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
/*
TEST(Table_6)
{
TestTableEnum table;
RLM_QUERY(TestQuery, TestTableEnum) {
// first.between(Mon, Thu);
second == "Hello" || (second == "Hey" && first == Mon);
}};
RLM_QUERY_OPT(TestQuery2, TestTableEnum) (Days a, Days b, const char* str) {
(void)b;
(void)a;
//first.between(a, b);
second == str || second.MatchRegEx(".*");
}};
//TestTableEnum result = table.find_all(TestQuery2(Mon, Tue, "Hello")).sort().Limit(10);
//size_t result2 = table.Range(10, 200).find_first(TestQuery());
//CHECK_EQUAL((size_t)-1, result2);
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
TEST(Table_FindAllInt)
{
TestTable table;
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
// Search for a value that does not exits
const TestTable::View v0 = table.column().second.find_all(5);
CHECK_EQUAL(0, v0.size());
// Search for a value with several matches
const TestTable::View v = table.column().second.find_all(20);
CHECK_EQUAL(5, v.size());
CHECK_EQUAL(1, v.get_source_ndx(0));
CHECK_EQUAL(3, v.get_source_ndx(1));
CHECK_EQUAL(5, v.get_source_ndx(2));
CHECK_EQUAL(7, v.get_source_ndx(3));
CHECK_EQUAL(9, v.get_source_ndx(4));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_SortedInt)
{
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, true, Wed); // 1: 7
table.add(0, 0, true, Wed); // 2: 0
table.add(0, 40, true, Wed); // 3: 8
table.add(0, 15, true, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Search for a value that does not exits
TestTable::View v = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v.size());
CHECK_EQUAL(2, v.get_source_ndx(0));
CHECK_EQUAL(9, v.get_source_ndx(1));
CHECK_EQUAL(7, v.get_source_ndx(2));
CHECK_EQUAL(6, v.get_source_ndx(3));
CHECK_EQUAL(0, v.get_source_ndx(4));
CHECK_EQUAL(5, v.get_source_ndx(5));
CHECK_EQUAL(4, v.get_source_ndx(6));
CHECK_EQUAL(1, v.get_source_ndx(7));
CHECK_EQUAL(3, v.get_source_ndx(8));
CHECK_EQUAL(8, v.get_source_ndx(9));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Sorted_Query_where)
{
// Using where(tv) instead of tableview(tv)
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, false, Wed); // 1: 7
table.add(0, 0, false, Wed); // 2: 0
table.add(0, 40, false, Wed); // 3: 8
table.add(0, 15, false, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Count booleans
size_t count_original = table.where().third.equal(false).count();
CHECK_EQUAL(4, count_original);
// Get a view containing the complete table
TestTable::View v = table.column().first.find_all(0);
CHECK_EQUAL(table.size(), v.size());
// Count booleans
size_t count_view = table.where(&v).third.equal(false).count();
CHECK_EQUAL(4, count_view);
TestTable::View v_sorted = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v_sorted.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Multi_Sort)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
table.add_empty_row(5);
// 1, 10
table.set_int(0, 0, 1);
table.set_int(1, 0, 10);
// 2, 10
table.set_int(0, 1, 2);
table.set_int(1, 1, 10);
// 0, 10
table.set_int(0, 2, 0);
table.set_int(1, 2, 10);
// 2, 14
table.set_int(0, 3, 2);
table.set_int(1, 3, 14);
// 1, 14
table.set_int(0, 4, 1);
table.set_int(1, 4, 14);
std::vector<size_t> col_ndx1;
col_ndx1.push_back(0);
col_ndx1.push_back(1);
std::vector<bool> asc;
asc.push_back(true);
asc.push_back(true);
// (0, 10); (1, 10); (1, 14); (2, 10); (2; 14)
TableView v_sorted1 = table.get_sorted_view(col_ndx1, asc);
CHECK_EQUAL(table.size(), v_sorted1.size());
CHECK_EQUAL(2, v_sorted1.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted1.get_source_ndx(1));
CHECK_EQUAL(4, v_sorted1.get_source_ndx(2));
CHECK_EQUAL(1, v_sorted1.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted1.get_source_ndx(4));
std::vector<size_t> col_ndx2;
col_ndx2.push_back(1);
col_ndx2.push_back(0);
// (0, 10); (1, 10); (2, 10); (1, 14); (2, 14)
TableView v_sorted2 = table.get_sorted_view(col_ndx2, asc);
CHECK_EQUAL(table.size(), v_sorted2.size());
CHECK_EQUAL(2, v_sorted2.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted2.get_source_ndx(1));
CHECK_EQUAL(1, v_sorted2.get_source_ndx(2));
CHECK_EQUAL(4, v_sorted2.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted2.get_source_ndx(4));
}
TEST(Table_IndexString)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); //duplicate
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
const size_t r1 = table.column().second.find_first("jimmi");
CHECK_EQUAL(not_found, r1);
const size_t r2 = table.column().second.find_first("jeff");
const size_t r3 = table.column().second.find_first("jim");
const size_t r4 = table.column().second.find_first("jimbo");
const size_t r5 = table.column().second.find_first("johnny");
CHECK_EQUAL(0, r2);
CHECK_EQUAL(1, r3);
CHECK_EQUAL(5, r4);
CHECK_EQUAL(6, r5);
const size_t c1 = table.column().second.count("jennifer");
CHECK_EQUAL(2, c1);
}
TEST(Table_IndexStringTwice)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); // duplicate
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
}
// Tests Table part of index on Int, DateTime and Bool columns. For a more exhaustive
// test of the integer index (bypassing Table), see test_index_string.cpp)
TEST(Table_IndexInteger)
{
Table table;
size_t r;
table.add_column(type_Int, "ints");
table.add_column(type_DateTime, "date");
table.add_column(type_Bool, "date");
table.add_empty_row(13);
table.set_int(0, 0, 3); // 0
table.set_int(0, 1, 1); // 1
table.set_int(0, 2, 2); // 2
table.set_int(0, 3, 2); // 3
table.set_int(0, 4, 2); // 4
table.set_int(0, 5, 3); // 5
table.set_int(0, 6, 3); // 6
table.set_int(0, 7, 2); // 7
table.set_int(0, 8, 4); // 8
table.set_int(0, 9, 2); // 9
table.set_int(0, 10, 6); // 10
table.set_int(0, 11, 2); // 11
table.set_int(0, 12, 3); // 12
table.add_search_index(0);
CHECK(table.has_search_index(0));
table.add_search_index(1);
CHECK(table.has_search_index(1));
table.add_search_index(2);
CHECK(table.has_search_index(2));
table.set_datetime(1, 10, DateTime(43));
r = table.find_first_datetime(1, DateTime(43));
CHECK_EQUAL(10, r);
table.set_bool(2, 11, true);
r = table.find_first_bool(2, true);
CHECK_EQUAL(11, r);
r = table.find_first_int(0, 11);
CHECK_EQUAL(not_found, r);
r = table.find_first_int(0, 3);
CHECK_EQUAL(0, r);
r = table.find_first_int(0, 4);
CHECK_EQUAL(8, r);
TableView tv = table.find_all_int(0, 2);
CHECK_EQUAL(6, tv.size());
CHECK_EQUAL(2, tv[0].get_index());
CHECK_EQUAL(3, tv[1].get_index());
CHECK_EQUAL(4, tv[2].get_index());
CHECK_EQUAL(7, tv[3].get_index());
CHECK_EQUAL(9, tv[4].get_index());
CHECK_EQUAL(11, tv[5].get_index());
}
TEST(Table_PrimaryKeyBasics)
{
// Note: Formally, member functions of Table are not required to leave the
// table in a valid state when they throw LogicError. In the cases below,
// however, informed by the actual implementation of these functions, we
// assume that they do allow us to continue, but please remember that this
// is not generally the case.
Table table;
table.add_column(type_String, "");
// Empty table
CHECK_NOT(table.has_primary_key());
CHECK_LOGIC_ERROR(table.find_pkey_string("foo"), LogicError::no_primary_key);
CHECK_LOGIC_ERROR(table.try_add_primary_key(0), LogicError::no_search_index);
table.add_search_index(0);
CHECK_NOT(table.has_primary_key());
CHECK_LOGIC_ERROR(table.find_pkey_string("foo"), LogicError::no_primary_key);
CHECK(table.try_add_primary_key(0));
CHECK(table.has_primary_key());
CHECK_NOT(table.find_pkey_string("foo"));
// One row
table.remove_primary_key();
table.add_empty_row();
table.set_string(0, 0, "foo");
CHECK_LOGIC_ERROR(table.find_pkey_string("foo"), LogicError::no_primary_key);
CHECK(table.try_add_primary_key(0));
CHECK_EQUAL(0, table.find_pkey_string("foo").get_index());
CHECK_NOT(table.find_pkey_string("bar"));
// Two rows
table.remove_primary_key();
table.add_empty_row();
table.set_string(0, 1, "bar");
CHECK(table.try_add_primary_key(0));
CHECK_EQUAL(0, table.find_pkey_string("foo").get_index());
CHECK_EQUAL(1, table.find_pkey_string("bar").get_index());
// Modify primary key
CHECK_LOGIC_ERROR(table.set_string(0, 1, "foo"), LogicError::unique_constraint_violation);
table.set_string(0, 1, "bar");
table.set_string(0, 1, "baz");
CHECK_EQUAL(0, table.find_pkey_string("foo").get_index());
CHECK_NOT(table.find_pkey_string("bar"));
CHECK_EQUAL(1, table.find_pkey_string("baz").get_index());
// Insert row
// Unfortunately, we could not have recovered and continued if we had let
// Table::insert_string() throw.
// CHECK_LOGIC_ERROR(table.insert_string(0, 2, "foo"), LogicError::unique_constraint_violation);
table.verify();
table.insert_empty_row(2);
table.set_string(0, 2, "bar");
table.verify();
table.add_empty_row();
table.verify();
// Unfortunately, we could not have recovered and continued if we had let
// Table::add_empty_row() throw.
// CHECK_LOGIC_ERROR(table.add_empty_row(), LogicError::unique_constraint_violation);
// Duplicate key value
table.remove_primary_key();
table.set_string(0, 1, "foo");
CHECK_NOT(table.try_add_primary_key(0));
}
TEST(Table_PrimaryKeyLargeCommonPrefix)
{
Table table;
table.add_column(type_String, "");
table.add_empty_row(2);
table.set_string(0, 0, "metasyntactic variable 1");
table.set_string(0, 1, "metasyntactic variable 2");
table.add_search_index(0);
CHECK(table.try_add_primary_key(0));
CHECK_LOGIC_ERROR(table.set_string(0, 1, "metasyntactic variable 1"),
LogicError::unique_constraint_violation);
table.set_string(0, 1, "metasyntactic variable 2");
table.set_string(0, 1, "metasyntactic variable 3");
}
TEST(Table_PrimaryKeyExtra)
{
Table table;
table.add_column(type_String, "");
table.add_column(type_Int, "");
table.add_empty_row(8);
table.set_string(0, 0, "jeff");
table.set_string(0, 1, "jim");
table.set_string(0, 2, "jennifer");
table.set_string(0, 3, "john");
table.set_string(0, 4, "jimmy");
table.set_string(0, 5, "jimbo");
table.set_string(0, 6, "johnny");
table.set_string(0, 7, "jennifer"); // Duplicate primary key
table.set_int(1, 0, 0);
table.set_int(1, 1, 1);
table.set_int(1, 2, 2);
table.set_int(1, 3, 3);
table.set_int(1, 4, 4);
table.set_int(1, 5, 5);
table.set_int(1, 6, 6);
table.set_int(1, 7, 7);
CHECK_LOGIC_ERROR(table.find_pkey_string("jeff"), LogicError::no_primary_key);
CHECK_LOGIC_ERROR(table.try_add_primary_key(0), LogicError::no_search_index);
CHECK_NOT(table.has_primary_key());
table.add_search_index(0);
CHECK(table.has_search_index(0));
CHECK_NOT(table.try_add_primary_key(0));
CHECK_NOT(table.has_primary_key());
table.set_string(0, 7, "jennifer 8");
CHECK(table.try_add_primary_key(0));
CHECK(table.has_primary_key());
table.verify();
Row a0 = table.find_pkey_string("jeff");
Row a1 = table.find_pkey_string("jim");
Row a2 = table.find_pkey_string("jennifer");
Row a3 = table.find_pkey_string("john");
Row a4 = table.find_pkey_string("jimmy");
Row a5 = table.find_pkey_string("jimbo");
Row a6 = table.find_pkey_string("johnny");
Row a7 = table.find_pkey_string("jerry");
CHECK(a0);
CHECK(a1);
CHECK(a2);
CHECK(a3);
CHECK(a4);
CHECK(a5);
CHECK(a6);
CHECK_NOT(a7);
CHECK_EQUAL(0, a0.get_index());
CHECK_EQUAL(1, a1.get_index());
CHECK_EQUAL(2, a2.get_index());
CHECK_EQUAL(3, a3.get_index());
CHECK_EQUAL(4, a4.get_index());
CHECK_EQUAL(5, a5.get_index());
CHECK_EQUAL(6, a6.get_index());
}
TEST(Table_SubtablePrimaryKey)
{
Table parent;
parent.add_column(type_Table, "");
parent.get_subdescriptor(0)->add_column(type_String, "");
parent.add_empty_row();
TableRef child = parent[0].get_subtable(0);
CHECK_LOGIC_ERROR(child->find_pkey_string("foo"), LogicError::no_primary_key);
CHECK_LOGIC_ERROR(child->add_search_index(0), LogicError::wrong_kind_of_table);
}
TEST(Table_Distinct)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
TestTableEnum::View view = table.column().second.get_distinct_view();
CHECK_EQUAL(4, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(5, view.get_source_ndx(3));
}
TEST(Table_DistinctEnums)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().first.add_search_index();
CHECK(table.column().first.has_search_index());
TestTableEnum::View view = table.column().first.get_distinct_view();
CHECK_EQUAL(7, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(3, view.get_source_ndx(3));
CHECK_EQUAL(4, view.get_source_ndx(4));
CHECK_EQUAL(5, view.get_source_ndx(5));
CHECK_EQUAL(6, view.get_source_ndx(6));
}
TEST(Table_DistinctIntegers)
{
Table table;
table.add_column(type_Int, "first");
table.add_empty_row(4);
table.set_int(0, 0, 1);
table.set_int(0, 1, 2);
table.set_int(0, 2, 3);
table.set_int(0, 3, 3);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
TEST(Table_DistinctBool)
{
Table table;
table.add_column(type_Bool, "first");
table.add_empty_row(4);
table.set_bool(0, 0, true);
table.set_bool(0, 1, false);
table.set_bool(0, 2, true);
table.set_bool(0, 3, false);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(2, view.size());
CHECK_EQUAL(0, view.get_source_ndx(1));
CHECK_EQUAL(1, view.get_source_ndx(0));
}
/*
// FIXME Commented out because indexes on floats and doubles are not supported (yet).
TEST(Table_DistinctFloat)
{
Table table;
table.add_column(type_Float, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_float(0, i, static_cast<float>(i) + 0.5f);
}
table.set_float(0, 10, 0.5f);
table.set_float(0, 11, 1.5f);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
TEST(Table_DistinctDouble)
{
Table table;
table.add_column(type_Double, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_double(0, i, static_cast<double>(i) + 0.5);
}
table.set_double(0, 10, 0.5);
table.set_double(0, 11, 1.5);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
*/
TEST(Table_DistinctDateTime)
{
Table table;
table.add_column(type_DateTime, "first");
table.add_empty_row(4);
table.set_datetime(0, 0, DateTime(0));
table.set_datetime(0, 1, DateTime(1));
table.set_datetime(0, 2, DateTime(3));
table.set_datetime(0, 3, DateTime(3));
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
}
TEST(Table_DistinctFromPersistedTable)
{
GROUP_TEST_PATH(path);
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "first");
table->add_empty_row(4);
table->set_int(0, 0, 1);
table->set_int(0, 1, 2);
table->set_int(0, 2, 3);
table->set_int(0, 3, 3);
table->add_search_index(0);
CHECK(table->has_search_index(0));
group.write(path);
}
{
Group group(path, 0, Group::mode_ReadOnly);
TableRef table = group.get_table("table");
TableView view = table->get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
}
TEST(Table_IndexInt)
{
TestTable table;
table.add(0, 1, true, Wed);
table.add(0, 15, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 11, true, Wed);
table.add(0, 45, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 0, true, Wed);
table.add(0, 30, true, Wed);
table.add(0, 9, true, Wed);
// Create index for column two
table.column().second.add_search_index();
// Search for a value that does not exits
const size_t r1 = table.column().second.find_first(2);
CHECK_EQUAL(npos, r1);
// Find existing values
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(10));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
//CHECK_EQUAL(6, table.column().second.find_first(10)); // only finds first match
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(9));
// Change some values
table[2].second = 13;
table[9].second = 100;
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
// Insert values
table.add(0, 29, true, Wed);
//TODO: More than add
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
CHECK_EQUAL(10, table.column().second.find_first(29));
// Delete some values
table.remove(0);
table.remove(5);
table.remove(8);
CHECK_EQUAL(0, table.column().second.find_first(15));
CHECK_EQUAL(1, table.column().second.find_first(13));
CHECK_EQUAL(2, table.column().second.find_first(20));
CHECK_EQUAL(3, table.column().second.find_first(11));
CHECK_EQUAL(4, table.column().second.find_first(45));
CHECK_EQUAL(5, table.column().second.find_first(0));
CHECK_EQUAL(6, table.column().second.find_first(30));
CHECK_EQUAL(7, table.column().second.find_first(100));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_4(TestTableAE,
first, Int,
second, String,
third, Bool,
fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_AutoEnumeration)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
for (size_t i = 0; i < 5; ++i) {
const size_t n = i * 5;
CHECK_EQUAL(1, table[0+n].first);
CHECK_EQUAL(2, table[1+n].first);
CHECK_EQUAL(5, table[2+n].first);
CHECK_EQUAL(8, table[3+n].first);
CHECK_EQUAL(9, table[4+n].first);
CHECK_EQUAL("abd", table[0+n].second);
CHECK_EQUAL("eftg", table[1+n].second);
CHECK_EQUAL("hijkl", table[2+n].second);
CHECK_EQUAL("mnopqr", table[3+n].second);
CHECK_EQUAL("stuvxyz", table[4+n].second);
CHECK_EQUAL(true, table[0+n].third);
CHECK_EQUAL(true, table[1+n].third);
CHECK_EQUAL(true, table[2+n].third);
CHECK_EQUAL(true, table[3+n].third);
CHECK_EQUAL(true, table[4+n].third);
CHECK_EQUAL(Mon, table[0+n].fourth);
CHECK_EQUAL(Tue, table[1+n].fourth);
CHECK_EQUAL(Wed, table[2+n].fourth);
CHECK_EQUAL(Thu, table[3+n].fourth);
CHECK_EQUAL(Fri, table[4+n].fourth);
}
// Verify counts
const size_t count1 = table.column().second.count("abd");
const size_t count2 = table.column().second.count("eftg");
const size_t count3 = table.column().second.count("hijkl");
const size_t count4 = table.column().second.count("mnopqr");
const size_t count5 = table.column().second.count("stuvxyz");
CHECK_EQUAL(5, count1);
CHECK_EQUAL(5, count2);
CHECK_EQUAL(5, count3);
CHECK_EQUAL(5, count4);
CHECK_EQUAL(5, count5);
}
TEST(Table_AutoEnumerationFindFindAll)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
size_t t = table.column().second.find_first("eftg");
CHECK_EQUAL(1, t);
TestTableAE::View tv = table.column().second.find_all("eftg");
CHECK_EQUAL(5, tv.size());
CHECK_EQUAL("eftg", tv[0].second);
CHECK_EQUAL("eftg", tv[1].second);
CHECK_EQUAL("eftg", tv[2].second);
CHECK_EQUAL("eftg", tv[3].second);
CHECK_EQUAL("eftg", tv[4].second);
}
namespace {
REALM_TABLE_4(TestTableEnum4,
col1, String,
col2, String,
col3, String,
col4, String)
} // anonymous namespace
TEST(Table_AutoEnumerationOptimize)
{
TestTableEnum4 t;
// Insert non-optimzable strings
std::string s;
for (size_t i = 0; i < 10; ++i) {
t.add(s.c_str(), s.c_str(), s.c_str(), s.c_str());
s += "x";
}
t.optimize();
// AutoEnumerate in reverse order
for (size_t i = 0; i < 10; ++i) {
t[i].col4 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col3 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col2 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col1 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
CHECK_EQUAL("test", t[i].col1);
CHECK_EQUAL("test", t[i].col2);
CHECK_EQUAL("test", t[i].col3);
CHECK_EQUAL("test", t[i].col4);
}
#ifdef REALM_DEBUG
t.verify();
#endif
}
namespace {
REALM_TABLE_1(TestSubtabEnum2,
str, String)
REALM_TABLE_1(TestSubtabEnum1,
subtab, Subtable<TestSubtabEnum2>)
} // anonymous namespace
TEST(Table_OptimizeSubtable)
{
TestSubtabEnum1 t;
t.add();
t.add();
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (int i=0; i<100; ++i) {
r->add(s.c_str());
s += 'x';
}
}
{
// Enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (int i=0; i<100; ++i) {
r->add("foo");
}
r->optimize();
}
// Verify
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL(s.c_str(), r[i].str);
s += 'x';
}
}
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL("foo", r[i].str);
}
}
}
TEST(Table_OptimizeCompare)
{
TestSubtabEnum2 t1, t2;
for (int i=0; i<100; ++i) {
t1.add("foo");
}
for (int i=0; i<100; ++i) {
t2.add("foo");
}
t1.optimize();
CHECK(t1 == t2);
t1[50].str = "bar";
CHECK(t1 != t2);
t1[50].str = "foo";
CHECK(t1 == t2);
t2[50].str = "bar";
CHECK(t1 != t2);
t2[50].str = "foo";
CHECK(t1 == t2);
}
TEST(Table_SlabAlloc)
{
SlabAlloc alloc;
alloc.attach_empty();
TestTable table(alloc);
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL( 0, r.first);
CHECK_EQUAL( 10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL( Wed, r.fourth);
// Add some more rows
table.add(1, 10, true, Wed);
table.add(2, 20, true, Wed);
table.add(3, 10, true, Wed);
table.add(4, 20, true, Wed);
table.add(5, 10, true, Wed);
// Delete some rows
table.remove(2);
table.remove(4);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Spec)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
{
DescriptorRef sub_1;
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third", &sub_1);
sub_1->add_column(type_Int, "sub_first");
sub_1->add_column(type_String, "sub_second");
}
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Write the group to disk
GROUP_TEST_PATH(path);
group.write(path);
// Read back tables
{
Group from_disk(path, 0, Group::mode_ReadOnly);
TableRef from_disk_table = from_disk.get_table("test");
TableRef subtable2 = from_disk_table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("test", subtable2->get_string(1, 0));
}
}
TEST(Table_SpecColumnPath)
{
Group group;
TableRef table = group.add_table("test");
// Create path to sub-table column (starting with root)
std::vector<size_t> column_path;
// Create specification with sub-table
table->add_subcolumn(column_path, type_Int, "first");
table->add_subcolumn(column_path, type_String, "second");
table->add_subcolumn(column_path, type_Table, "third");
column_path.push_back(2); // third column (which is a sub-table col)
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
}
TEST(Table_SpecRenameColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Rename first column
table->rename_column(0, "1st");
CHECK_EQUAL(0, table->get_column_index("1st"));
// Rename sub-column
table->rename_subcolumn(column_path, 0, "sub_1st"); // third
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(0, subtable->get_column_index("sub_1st"));
}
}
TEST(Table_SpecDeleteColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
table->add_column(type_String, "fourth"); // will be auto-enumerated
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(4, table->get_column_count());
// Add a few rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->set_string(3, 0, "X");
table->insert_empty_row(1);
table->set_int(0, 1, 4);
table->set_string(1, 1, "World");
table->set_string(3, 1, "X");
table->insert_empty_row(2);
table->set_int(0, 2, 4);
table->set_string(1, 2, "Goodbye");
table->set_string(3, 2, "X");
// We want the last column to be StringEnum column
table->optimize();
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Remove the first column
table->remove_column(0);
CHECK_EQUAL(3, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(2, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Create path to column in sub-table
column_path.clear();
column_path.push_back(1); // third
// Remove a column in sub-table
table->remove_subcolumn(column_path, 1); // sub_second
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(1, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
}
// Remove sub-table column (with all members)
table->remove_column(1);
CHECK_EQUAL(2, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(1, 0));
// Remove optimized string column
table->remove_column(1);
CHECK_EQUAL(1, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
// Remove last column
table->remove_column(0);
CHECK_EQUAL(0, table->get_column_count());
CHECK(table->is_empty());
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_NullInEnum)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "second", true);
for (size_t c = 0; c < 100; c++) {
table->insert_empty_row(c);
table->set_string(0, c, "hello");
}
size_t r;
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->optimize();
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->set_string(0, 50, "hello");
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
table->set_string(0, 55, realm::null());
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(2, r);
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(98, r);
table->remove(55);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
}
TEST(Table_SpecAddColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Add a new bool column
table->add_column(type_Bool, "fourth");
CHECK_EQUAL(4, table->get_column_count());
CHECK_EQUAL(false, table->get_bool(3, 0));
// Add a new string column
table->add_column(type_String, "fifth");
CHECK_EQUAL(5, table->get_column_count());
CHECK_EQUAL("", table->get_string(4, 0));
// Add a new table column
table->add_column(type_Table, "sixth");
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(0, table->get_subtable_size(5, 0));
// Add a new mixed column
table->add_column(type_Mixed, "seventh");
CHECK_EQUAL(7, table->get_column_count());
CHECK_EQUAL(0, table->get_mixed(6, 0).get_int());
// Create path to column in sub-table
column_path.clear();
column_path.push_back(2); // third
// Add new int column to sub-table
table->add_subcolumn(column_path, type_Int, "sub_third");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(3, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
}
// Add new table column to sub-table
table->add_subcolumn(column_path, type_Table, "sub_fourth");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
CHECK_EQUAL(0, subtable->get_subtable_size(3, 0));
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
}
// Add new column to new sub-table
column_path.push_back(3); // sub_forth
table->add_subcolumn(column_path, type_String, "first");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
TableRef subsubtable = subtable->get_subtable(3, 0);
CHECK_EQUAL(1, subsubtable->get_column_count());
}
// Add a new mixed column
table->add_column(type_Mixed, "eighth");
CHECK_EQUAL(8, table->get_column_count());
table->set_mixed(7, 0, Mixed::subtable_tag());
TableRef stab = table->get_subtable(7, 0);
stab->add_column(type_Int, "smurf");
stab->insert_empty_row(0);
stab->set_int(0, 0, 1);
stab->insert_empty_row(1);
stab->set_int(0, 1, 2);
CHECK_EQUAL(2, table->get_subtable_size(7, 0));
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_SpecDeleteColumnsBug)
{
TableRef table = Table::create();
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_search_index(0);
table->add_column(type_Int, "age");
table->add_column(type_Bool, "hired");
table->add_column(type_Table, "phones");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(3); // phones
table->add_subcolumn(column_path, type_String, "type");
table->add_subcolumn(column_path, type_String, "number");
// Add rows
table->add_empty_row();
table->set_string(0, 0, "jessica");
table->set_int(1, 0, 22);
table->set_bool(2, 0, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "232-323-3242");
}
table->add_empty_row();
table->set_string(0, 1, "joe");
table->set_int(1, 1, 42);
table->set_bool(2, 1, false);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "work");
phones->set_string(1, 0, "434-434-4343");
}
table->add_empty_row();
table->set_string(0, 1, "jared");
table->set_int(1, 1, 35);
table->set_bool(2, 1, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "342-323-3242");
phones->add_empty_row();
phones->set_string(0, 0, "school");
phones->set_string(1, 0, "434-432-5433");
}
// Add new column
table->add_column(type_Mixed, "extra");
table->set_mixed(4, 0, true);
table->set_mixed(4, 2, "Random string!");
// Remove some columns
table->remove_column(1); // age
table->remove_column(3); // extra
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_Mixed)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Mixed, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Mixed, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
const size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_mixed(1, ndx, true);
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
table.insert_empty_row(1);
table.set_int(0, 1, 43);
table.set_mixed(1, 1, (int64_t)12);
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
table.insert_empty_row(2);
table.set_int(0, 2, 100);
table.set_mixed(1, 2, "test");
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
table.insert_empty_row(3);
table.set_int(0, 3, 0);
table.set_mixed(1, 3, DateTime(324234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime,table.get_mixed(1, 3).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
table.insert_empty_row(4);
table.set_int(0, 4, 43);
table.set_mixed(1, 4, Mixed(BinaryData("binary", 7)));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
table.insert_empty_row(5);
table.set_int(0, 5, 0);
table.set_mixed(1, 5, Mixed::subtable_tag());
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
// Get table from mixed column and add schema and some values
TableRef subtable = table.get_subtable(1, 5);
subtable->add_column(type_String, "name");
subtable->add_column(type_Int, "age");
subtable->insert_empty_row(0);
subtable->set_string(0, 0, "John");
subtable->set_int(1, 0, 40);
// Get same table again and verify values
TableRef subtable2 = table.get_subtable(1, 5);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL("John", subtable2->get_string(0, 0));
CHECK_EQUAL(40, subtable2->get_int(1, 0));
// Insert float, double
table.insert_empty_row(6);
table.set_int(0, 6, 31);
table.set_mixed(1, 6, float(1.123));
table.insert_empty_row(7);
table.set_int(0, 7, 0);
table.set_mixed(1, 7, double(2.234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(31, table.get_int(0, 6));
CHECK_EQUAL(0, table.get_int(0, 7));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(type_Float, table.get_mixed(1, 6).get_type());
CHECK_EQUAL(type_Double, table.get_mixed(1, 7).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
CHECK_EQUAL(float(1.123), table.get_mixed(1, 6).get_float());
CHECK_EQUAL(double(2.234), table.get_mixed(1, 7).get_double());
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_1(TestTableMX,
first, Mixed)
} // anonymous namespace
TEST(Table_Mixed2)
{
TestTableMX table;
table.add(int64_t(1));
table.add(true);
table.add(DateTime(1234));
table.add("test");
CHECK_EQUAL(type_Int, table[0].first.get_type());
CHECK_EQUAL(type_Bool, table[1].first.get_type());
CHECK_EQUAL(type_DateTime, table[2].first.get_type());
CHECK_EQUAL(type_String, table[3].first.get_type());
CHECK_EQUAL(1, table[0].first.get_int());
CHECK_EQUAL(true, table[1].first.get_bool());
CHECK_EQUAL(1234, table[2].first.get_datetime());
CHECK_EQUAL("test", table[3].first.get_string());
}
TEST(Table_SubtableSizeAndClear)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "subtab", &subdesc);
table.add_column(type_Mixed, "mixed");
subdesc->add_column(type_Int, "int");
table.insert_empty_row(0);
table.insert_empty_row(1);
Table subtable;
table.set_mixed_subtable(1, 1, &subtable);
CHECK_EQUAL(0, table.get_subtable_size(0,0)); // Subtable column
CHECK_EQUAL(0, table.get_subtable_size(1,0)); // Mixed column, bool value
CHECK_EQUAL(0, table.get_subtable_size(1,1)); // Mixed column, table value
CHECK(table.get_subtable(0,0)); // Subtable column
CHECK(!table.get_subtable(1,0)); // Mixed column, bool value, must return nullptr
CHECK(table.get_subtable(1,1)); // Mixed column, table value
table.set_mixed(1, 0, Mixed::subtable_tag());
table.set_mixed(1, 1, false);
CHECK(table.get_subtable(1,0));
CHECK(!table.get_subtable(1,1));
TableRef subtab1 = table.get_subtable(0,0);
TableRef subtab2 = table.get_subtable(1,0);
subtab2->add_column(type_Int, "int");
CHECK_EQUAL(0, table.get_subtable_size(1,0));
CHECK(table.get_subtable(1,0));
subtab1->insert_empty_row(0);
subtab2->insert_empty_row(0);
CHECK_EQUAL(1, table.get_subtable_size(0,0));
CHECK_EQUAL(1, table.get_subtable_size(1,0));
table.clear_subtable(0,0);
table.clear_subtable(1,0);
CHECK_EQUAL(0, table.get_subtable_size(0,0));
CHECK_EQUAL(0, table.get_subtable_size(1,0));
CHECK(table.get_subtable(1,0));
}
TEST(Table_LowLevelSubtables)
{
Table table;
std::vector<size_t> column_path;
table.add_column(type_Table, "subtab");
table.add_column(type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
table.add_empty_row(2);
CHECK_EQUAL(2, table.size());
for (int i_1 = 0; i_1 != 2; ++i_1) {
TableRef subtab = table.get_subtable(0, i_1);
subtab->add_empty_row(2 + i_1);
CHECK_EQUAL(2 + i_1, subtab->size());
{
TableRef subsubtab = subtab->get_subtable(0, 0 + i_1);
subsubtab->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 3 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab->clear_subtable(1, 1 + i_1); // Mixed
TableRef subsubtab_mix = subtab->get_subtable(1, 1 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(1 + i_1);
CHECK_EQUAL(1 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 1 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 1 + i_1, bool(subtab->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 0 + i_1 ? 3 + i_1 : 0, subtab->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 1 + i_1 ? 1 + i_1 : 0, subtab->get_subtable_size(1, i_2)); // Mixed
}
table.clear_subtable(1, i_1); // Mixed
TableRef subtab_mix = table.get_subtable(1, i_1);
std::vector<size_t> subcol_path;
subtab_mix->add_column(type_Table, "subtab");
subtab_mix->add_column(type_Mixed, "mixed");
subcol_path.push_back(0);
subtab_mix->add_subcolumn(subcol_path, type_Table, "subtab");
subtab_mix->add_subcolumn(subcol_path, type_Mixed, "mixed");
subtab_mix->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subtab_mix->size());
{
TableRef subsubtab = subtab_mix->get_subtable(0, 1 + i_1);
subsubtab->add_empty_row(7 + i_1);
CHECK_EQUAL(7 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 7 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab_mix->clear_subtable(1, 2 + i_1); // Mixed
TableRef subsubtab_mix = subtab_mix->get_subtable(1, 2 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(5 + i_1);
CHECK_EQUAL(5 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 5 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab_mix->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 2 + i_1, bool(subtab_mix->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 1 + i_1 ? 7 + i_1 : 0, subtab_mix->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 2 + i_1 ? 5 + i_1 : 0, subtab_mix->get_subtable_size(1, i_2)); // Mixed
}
CHECK_EQUAL(true, bool(table.get_subtable(0, i_1)));
CHECK_EQUAL(true, bool(table.get_subtable(1, i_1))); // Mixed
CHECK_EQUAL(2 + i_1, table.get_subtable_size(0, i_1));
CHECK_EQUAL(3 + i_1, table.get_subtable_size(1, i_1)); // Mixed
}
}
namespace {
REALM_TABLE_2(MyTable1,
val, Int,
val2, Int)
REALM_TABLE_2(MyTable2,
val, Int,
subtab, Subtable<MyTable1>)
REALM_TABLE_1(MyTable3,
subtab, Subtable<MyTable2>)
REALM_TABLE_1(MyTable4,
mix, Mixed)
} // anonymous namespace
TEST(Table_HighLevelSubtables)
{
MyTable3 t;
{
MyTable3::Ref r1 = t.get_table_ref();
MyTable3::ConstRef r2 = t.get_table_ref();
MyTable3::ConstRef r3 = r2->get_table_ref();
r3 = t.get_table_ref(); // Also test assigment that converts to const
static_cast<void>(r1);
static_cast<void>(r3);
}
t.add();
const MyTable3& ct = t;
{
MyTable2::Ref s1 = t[0].subtab;
MyTable2::ConstRef s2 = t[0].subtab;
MyTable2::Ref s3 = t[0].subtab->get_table_ref();
MyTable2::ConstRef s4 = t[0].subtab->get_table_ref();
MyTable2::Ref s5 = t.column().subtab[0];
MyTable2::ConstRef s6 = t.column().subtab[0];
MyTable2::Ref s7 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef s8 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef cs1 = ct[0].subtab;
MyTable2::ConstRef cs2 = ct[0].subtab->get_table_ref();
MyTable2::ConstRef cs3 = ct.column().subtab[0];
MyTable2::ConstRef cs4 = ct.column().subtab[0]->get_table_ref();
s1 = t[0].subtab;
s2 = t[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab->add();
{
MyTable1::Ref s1 = t[0].subtab[0].subtab;
MyTable1::ConstRef s2 = t[0].subtab[0].subtab;
MyTable1::Ref s3 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef s4 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::Ref s5 = t.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef s6 = t.column().subtab[0]->column().subtab[0];
MyTable1::Ref s7 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef s8 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef cs1 = ct[0].subtab[0].subtab;
MyTable1::ConstRef cs2 = ct[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef cs3 = ct.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef cs4 = ct.column().subtab[0]->column().subtab[0]->get_table_ref();
s1 = t[0].subtab[0].subtab;
s2 = t[0].subtab[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab[0].val = 1;
CHECK_EQUAL(t[0].subtab[0].val, 1);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 1);
CHECK_EQUAL(t[0].subtab->column().val[0], 1);
CHECK_EQUAL(t.column().subtab[0][0].val, 1);
t.column().subtab[0]->column().val[0] = 2;
CHECK_EQUAL(t[0].subtab[0].val, 2);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 2);
CHECK_EQUAL(t[0].subtab->column().val[0], 2);
CHECK_EQUAL(t.column().subtab[0][0].val, 2);
t[0].subtab->column().val[0] = 3;
CHECK_EQUAL(t[0].subtab[0].val, 3);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 3);
CHECK_EQUAL(t[0].subtab->column().val[0], 3);
CHECK_EQUAL(t.column().subtab[0][0].val, 3);
t.column().subtab[0][0].val = 4;
CHECK_EQUAL(t[0].subtab[0].val, 4);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(t[0].subtab->column().val[0], 4);
CHECK_EQUAL(t.column().subtab[0][0].val, 4);
CHECK_EQUAL(ct[0].subtab[0].val, 4);
CHECK_EQUAL(ct.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(ct[0].subtab->column().val[0], 4);
CHECK_EQUAL(ct.column().subtab[0][0].val, 4);
t[0].subtab[0].subtab->add();
t[0].subtab[0].subtab[0].val = 5;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 5);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 5);
t.column().subtab[0]->column().subtab[0]->column().val[0] = 6;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 6);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 6);
/*
Idea for compile time failure tests:
const MyTable2 t;
#if TEST_INDEX == 0
t[0].val = 7;
#elsif TEST_INDEX == 1
t.column().val[0] = 7;
#elsif TEST_INDEX == 2
t[0].subtab[0].val = 7;
#elsif TEST_INDEX == 3
t[0].subtab->column().val[0] = 7;
#endif
*/
}
TEST(Table_SubtableCopyOnSetAndInsert)
{
MyTable1 t1;
t1.add(7, 8);
MyTable2 t2;
t2.add(9, &t1);
MyTable1::Ref r1 = t2[0].subtab;
CHECK(t1 == *r1);
MyTable4 t4;
t4.add();
t4[0].mix.set_subtable(t2);
MyTable2::Ref r2 = unchecked_cast<MyTable2>(t4[0].mix.get_subtable());
CHECK(t2 == *r2);
}
TEST(Table_SetMethod)
{
MyTable1 t;
t.add(8, 9);
CHECK_EQUAL(t[0].val, 8);
CHECK_EQUAL(t[0].val2, 9);
t.set(0, 2, 4);
CHECK_EQUAL(t[0].val, 2);
CHECK_EQUAL(t[0].val2, 4);
}
namespace {
REALM_TABLE_2(TableDateAndBinary,
date, DateTime,
bin, Binary)
} // anonymous namespace
TEST(Table_DateAndBinary)
{
{
TableDateAndBinary t;
const size_t size = 10;
char data[size];
for (size_t i=0; i<size; ++i) data[i] = (char)i;
t.add(8, BinaryData(data, size));
CHECK_EQUAL(t[0].date, 8);
CHECK_EQUAL(t[0].bin.size(), size);
CHECK(std::equal(t[0].bin.data(), t[0].bin.data()+size, data));
}
// Test that 64-bit dates are preserved
{
TableDateAndBinary t;
int64_t date = std::numeric_limits<int64_t>::max() - 400;
t.add(date, BinaryData(""));
CHECK_EQUAL(t[0].date.get().get_datetime(), date);
}
}
// Test for a specific bug found: Calling clear on a group with a table with a subtable
TEST(Table_ClearWithSubtableAndGroup)
{
Group group;
TableRef table = group.add_table("test");
DescriptorRef sub_1;
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_column(type_Table, "sub", &sub_1);
sub_1->add_column(type_Int, "num");
CHECK_EQUAL(2, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_string(0, 0, "Foo");
CHECK_EQUAL(0, table->get_subtable_size(1, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(1, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 123);
CHECK_EQUAL(123, subtable->get_int(0, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(1, 0));
table->clear();
}
//set a subtable in an already exisitng row by providing an existing subtable as the example to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample2?
TEST(Table_SetSubTableByExample1)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// create a freestanding table to be used as a source by set_subtable
Table sub = Table();
sub.add_column(type_Int,"sub_first");
sub.add_column(type_String,"sub_second");
sub.add_empty_row();
sub.set_int(0,0,42);
sub.set_string(1,0,"forty two");
sub.add_empty_row();
sub.set_int(0,1,3);
sub.set_string(1,1,"PI");
// Get the sub-table back for inspection
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
//add a subtable into the row, resembling the sub we just created
table->set_subtable(2,0,&sub);
TableRef subtable2 = table->get_subtable(2, 0);
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1,1));
}
}
//In the tableview class, set a subtable in an already exisitng row by providing an existing subtable as the example to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample1?
TEST(Table_SetSubTableByExample2)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add two rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->insert_empty_row(1);
table->set_int(0, 1, 8);
table->set_string(1, 1, "Hi!, Hello?");
Table sub = Table();
sub.add_column(type_Int,"sub_first");
sub.add_column(type_String,"sub_second");
sub.add_empty_row();
sub.set_int(0,0,42);
sub.set_string(1,0,"forty two");
sub.add_empty_row();
sub.set_int(0,1,3);
sub.set_string(1,1,"PI");
//create a tableview with the table as source
TableView view = table->find_all_int(0,8);//select the second of the two rows
// Verify the sub table is empty
{
TableRef subtable = view.get_subtable(2, 0);
CHECK(subtable->is_empty());
//add a subtable into the second table row (first view row), resembling the sub we just created
view.set_subtable(2,0,&sub);
TableRef subtable2 = view.get_subtable(2, 0);//fetch back the subtable from the view
CHECK_EQUAL(false, subtable->is_empty());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1,1));
TableRef subtable3 = table->get_subtable(2, 1);//fetch back the subtable from the table.
CHECK_EQUAL(42, subtable3->get_int(0, 0));
CHECK_EQUAL("forty two", subtable3->get_string(1, 0));
CHECK_EQUAL(3, subtable3->get_int(0, 1));
CHECK_EQUAL("PI", subtable3->get_string(1,1));
}
}
TEST(Table_HasSharedSpec)
{
MyTable2 table1;
CHECK(!table1.has_shared_type());
Group g;
MyTable2::Ref table2 = g.add_table<MyTable2>("foo");
CHECK(!table2->has_shared_type());
table2->add();
CHECK(table2[0].subtab->has_shared_type());
// Subtable in mixed column
TestTableMX::Ref table3 = g.add_table<TestTableMX>("bar");
CHECK(!table3->has_shared_type());
table3->add();
table3[0].first.set_subtable<MyTable2>();
MyTable2::Ref table4 = table3[0].first.get_subtable<MyTable2>();
CHECK(table4);
CHECK(!table4->has_shared_type());
table4->add();
CHECK(!table4->has_shared_type());
CHECK(table4[0].subtab->has_shared_type());
}
namespace {
REALM_TABLE_3(TableAgg,
c_int, Int,
c_float, Float,
c_double, Double)
// TODO: Bool? DateTime
} // anonymous namespace
#if TEST_DURATION > 0
#define TBL_SIZE REALM_MAX_BPNODE_SIZE*10
#else
#define TBL_SIZE 10
#endif
TEST(Table_Aggregates)
{
TableAgg table;
int64_t i_sum = 0;
double f_sum = 0;
double d_sum = 0;
for (int i = 0; i < TBL_SIZE; i++) {
table.add(5987654, 4.0f, 3.0);
i_sum += 5987654;
f_sum += 4.0f;
d_sum += 3.0;
}
table.add(1, 1.1f, 1.2);
table.add(987654321, 11.0f, 12.0);
table.add(5, 4.0f, 3.0);
i_sum += 1 + 987654321 + 5;
f_sum += double(1.1f) + double(11.0f) + double(4.0f);
d_sum += 1.2 + 12.0 + 3.0;
double size = TBL_SIZE + 3;
double epsilon = std::numeric_limits<double>::epsilon();
// minimum
CHECK_EQUAL(1, table.column().c_int.minimum());
CHECK_EQUAL(1.1f, table.column().c_float.minimum());
CHECK_EQUAL(1.2, table.column().c_double.minimum());
// maximum
CHECK_EQUAL(987654321, table.column().c_int.maximum());
CHECK_EQUAL(11.0f, table.column().c_float.maximum());
CHECK_EQUAL(12.0, table.column().c_double.maximum());
// sum
CHECK_APPROXIMATELY_EQUAL(double(i_sum), double(table.column().c_int.sum()), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum, table.column().c_float.sum(), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum, table.column().c_double.sum(), 10*epsilon);
// average
CHECK_APPROXIMATELY_EQUAL(i_sum/size, table.column().c_int.average(), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum/size, table.column().c_float.average(), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum/size, table.column().c_double.average(), 10*epsilon);
}
namespace {
REALM_TABLE_1(TableAgg2,
c_count, Int)
} // anonymous namespace
TEST(Table_Aggregates2)
{
TableAgg2 table;
int c = -420;
int s = 0;
while (c < -20) {
table.add(c);
s += c;
c++;
}
CHECK_EQUAL(-420, table.column().c_count.minimum());
CHECK_EQUAL(-21, table.column().c_count.maximum());
CHECK_EQUAL(s, table.column().c_count.sum());
}
// Test Table methods max, min, avg, sum, on both nullable and non-nullable columns
TEST(Table_Aggregates3)
{
bool nullable = false;
for (int i = 0; i < 2; i++) {
// First we test everything with columns being nullable and with each column having at least 1 null
// Then we test everything with non-nullable columns where the null entries will instead be just
// 0, 0.0, etc.
nullable = (i == 1);
Group g;
TableRef table = g.add_table("Inventory");
table->insert_column(0, type_Int, "Price", nullable);
table->insert_column(1, type_Float, "Shipping", nullable);
table->insert_column(2, type_Double, "Rating", nullable);
table->insert_column(3, type_DateTime, "Delivery date", nullable);
table->add_empty_row(3);
table->set_int(0, 0, 1);
// table->set_null(0, 1);
table->set_int(0, 2, 3);
// table->set_null(1, 0);
// table->set_null(1, 1);
table->set_float(1, 2, 30.f);
table->set_double(2, 0, 1.1);
table->set_double(2, 1, 2.2);
// table->set_null(2, 2);
table->set_datetime(3, 0, DateTime(2016, 2, 2));
// table->set_null(3, 1);
table->set_datetime(3, 2, DateTime(2016, 6, 6));
size_t count;
size_t pos;
if (i == 1) {
// This i == 1 is the NULLABLE case where columns are nullable
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_datetime(3, &pos), DateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0, &pos), 1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_double(2, &pos), 1.1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_datetime(3, &pos), DateTime(2016, 2, 2));
CHECK_EQUAL(pos, 0);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3) / 2., 0.01);
CHECK_EQUAL(count, 2);
count = 123;
CHECK_EQUAL(table->average_float(1, &count), 30.f);
CHECK_EQUAL(count, 1);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2) / 2., 0.01);
CHECK_EQUAL(count, 2);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
else {
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_datetime(3, &pos), DateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0, &pos), 0);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->minimum_float(1, &pos), 0.f);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_double(2, &pos), 0.);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_datetime(3, &pos), DateTime(0));
CHECK_EQUAL(pos, 1);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3 + 0) / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_float(1, &count), 30.f / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2 + 0.) / 3., 0.01);
CHECK_EQUAL(count, 3);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
}
}
TEST(Table_LanguageBindings)
{
Table* table = LangBindHelper::new_table();
CHECK(table->is_attached());
table->add_column(type_Int, "i");
table->insert_empty_row(0);
table->set_int(0, 0, 10);
table->insert_empty_row(1);
table->set_int(0, 1, 12);
Table* table2 = LangBindHelper::copy_table(*table);
CHECK(table2->is_attached());
CHECK(*table == *table2);
LangBindHelper::unbind_table_ptr(table);
LangBindHelper::unbind_table_ptr(table2);
}
TEST(Table_MultipleColumn)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "first");
CHECK_EQUAL(table.get_column_count(), 2);
CHECK_EQUAL(table.get_column_index("first"), 0);
}
TEST(Table_FormerLeakCase)
{
Table sub;
sub.add_column(type_Int, "a");
Table root;
DescriptorRef subdesc;
root.add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "a");
root.add_empty_row(1);
root.set_subtable(0, 0, &sub);
root.set_subtable(0, 0, 0);
}
namespace {
REALM_TABLE_3(TablePivotAgg,
sex, String,
age, Int,
hired, Bool)
} // anonymous namespace
TEST(Table_Pivot)
{
size_t count = 1717;
TablePivotAgg table;
int64_t age_sum[2] = {0, 0};
int64_t age_cnt[2] = {0, 0};
int64_t age_min[2];
int64_t age_max[2];
double age_avg[2];
for (size_t i = 0; i < count; ++i) {
size_t sex = i % 2;
int64_t age = 3 + (i%117);
table.add((sex==0) ? "Male" : "Female", age, true);
age_sum[sex] += age;
age_cnt[sex] += 1;
if ((i < 2) || age < age_min[sex])
age_min[sex] = age;
if ((i < 2) || age > age_max[sex])
age_max[sex] = age;
}
for (size_t sex = 0; sex < 2; ++sex) {
age_avg[sex] = double(age_sum[sex]) / double(age_cnt[sex]);
}
for (int i = 0; i < 2; ++i) {
Table result_count;
table.aggregate(0, 1, Table::aggr_count, result_count);
CHECK_EQUAL(2, result_count.get_column_count());
CHECK_EQUAL(2, result_count.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_cnt[sex], result_count.get_int(1, sex));
}
Table result_sum;
table.aggregate(0, 1, Table::aggr_sum, result_sum);
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_sum[sex], result_sum.get_int(1, sex));
}
Table result_avg;
table.aggregate(0, 1, Table::aggr_avg, result_avg);
if ((false)) {
std::ostringstream ss;
result_avg.to_string(ss);
std::cerr << "\nMax:\n" << ss.str();
}
CHECK_EQUAL(2, result_avg.get_column_count());
CHECK_EQUAL(2, result_avg.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_avg[sex], result_avg.get_double(1, sex));
}
Table result_min;
table.aggregate(0, 1, Table::aggr_min, result_min);
CHECK_EQUAL(2, result_min.get_column_count());
CHECK_EQUAL(2, result_min.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_min[sex], result_min.get_int(1, sex));
}
Table result_max;
table.aggregate(0, 1, Table::aggr_max, result_max);
CHECK_EQUAL(2, result_max.get_column_count());
CHECK_EQUAL(2, result_max.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_max[sex], result_max.get_int(1, sex));
}
// Test with enumerated strings in second loop
table.optimize();
}
}
namespace {
void compare_table_with_slice(TestResults& test_results, const Table& table,
const Table& slice, size_t offset, size_t size)
{
ConstDescriptorRef table_desc = table.get_descriptor();
ConstDescriptorRef slice_desc = slice.get_descriptor();
CHECK(*table_desc == *slice_desc);
if (*table_desc != *slice_desc)
return;
size_t num_cols = table.get_column_count();
for (size_t col_i = 0; col_i != num_cols; ++col_i) {
DataType type = table.get_column_type(col_i);
switch (type) {
case type_Int:
case type_Link:
for (size_t i = 0; i != size; ++i) {
int_fast64_t v_1 = table.get_int(col_i, offset + i);
int_fast64_t v_2 = slice.get_int(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Bool:
for (size_t i = 0; i != size; ++i) {
bool v_1 = table.get_bool(col_i, offset + i);
bool v_2 = slice.get_bool(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Float:
for (size_t i = 0; i != size; ++i) {
float v_1 = table.get_float(col_i, offset + i);
float v_2 = slice.get_float(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Double:
for (size_t i = 0; i != size; ++i) {
double v_1 = table.get_double(col_i, offset + i);
double v_2 = slice.get_double(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_String:
for (size_t i = 0; i != size; ++i) {
StringData v_1 = table.get_string(col_i, offset + i);
StringData v_2 = slice.get_string(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Binary:
for (size_t i = 0; i != size; ++i) {
BinaryData v_1 = table.get_binary(col_i, offset + i);
BinaryData v_2 = slice.get_binary(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_DateTime:
for (size_t i = 0; i != size; ++i) {
DateTime v_1 = table.get_datetime(col_i, offset + i);
DateTime v_2 = slice.get_datetime(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Table:
for (size_t i = 0; i != size; ++i) {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
}
break;
case type_Mixed:
for (size_t i = 0; i != size; ++i) {
Mixed v_1 = table.get_mixed(col_i, offset + i);
Mixed v_2 = slice.get_mixed(col_i, i);
CHECK_EQUAL(v_1.get_type(), v_2.get_type());
if (v_1.get_type() == v_2.get_type()) {
switch (v_1.get_type()) {
case type_Int:
CHECK_EQUAL(v_1.get_int(), v_2.get_int());
break;
case type_Bool:
CHECK_EQUAL(v_1.get_bool(), v_2.get_bool());
break;
case type_Float:
CHECK_EQUAL(v_1.get_float(), v_2.get_float());
break;
case type_Double:
CHECK_EQUAL(v_1.get_double(), v_2.get_double());
break;
case type_String:
CHECK_EQUAL(v_1.get_string(), v_2.get_string());
break;
case type_Binary:
CHECK_EQUAL(v_1.get_binary(), v_2.get_binary());
break;
case type_DateTime:
CHECK_EQUAL(v_1.get_datetime(), v_2.get_datetime());
break;
case type_Table: {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
break;
}
case type_Mixed:
case type_Link:
case type_LinkList:
REALM_ASSERT(false);
}
}
}
break;
case type_LinkList:
break;
}
}
}
void test_write_slice_name(TestResults& test_results, const Table& table,
StringData expect_name, bool override_name)
{
size_t offset = 0, size = 0;
std::ostringstream out;
if (override_name) {
table.write(out, offset, size, expect_name);
}
else {
table.write(out, offset, size);
}
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table(expect_name);
CHECK(slice);
}
void test_write_slice_contents(TestResults& test_results, const Table& table,
size_t offset, size_t size)
{
std::ostringstream out;
table.write(out, offset, size);
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table("test");
CHECK(slice);
if (slice) {
size_t remaining_size = table.size() - offset;
size_t size_2 = size;
if (size_2 > remaining_size)
size_2 = remaining_size;
CHECK_EQUAL(size_2, slice->size());
if (size_2 == slice->size())
compare_table_with_slice(test_results, table, *slice, offset, size_2);
}
}
} // anonymous namespace
TEST(Table_WriteSlice)
{
// check that the name of the written table is as expected
{
Table table;
test_write_slice_name(test_results, table, "", false);
test_write_slice_name(test_results, table, "foo", true); // Override
test_write_slice_name(test_results, table, "", true); // Override
}
{
Group group;
TableRef table = group.add_table("test");
test_write_slice_name(test_results, *table, "test", false);
test_write_slice_name(test_results, *table, "foo", true); // Override
test_write_slice_name(test_results, *table, "", true); // Override
}
// Run through a 3-D matrix of table sizes, slice offsets, and
// slice sizes. Each test involves a table with columns of each
// possible type.
#ifdef REALM_DEBUG
int table_sizes[] = { 0, 1, 2, 3, 5, 9, 27, 81, 82, 135 };
#else
int table_sizes[] = { 0, 1, 2, 3, 5, 9, 27, 81, 82, 243, 729, 2187, 6561 };
#endif
int num_sizes = sizeof table_sizes / sizeof *table_sizes;
for (int table_size_i = 0; table_size_i != num_sizes; ++table_size_i) {
int table_size = table_sizes[table_size_i];
Group group;
TableRef table = group.add_table("test");
bool fixed_subtab_sizes = true;
setup_multi_table(*table, table_size, 1, fixed_subtab_sizes);
for (int offset_i = 0; offset_i != num_sizes; ++offset_i) {
int offset = table_sizes[offset_i];
if (offset > table_size)
break;
for (int size_i = 0; size_i != num_sizes; ++size_i) {
int size = table_sizes[size_i];
// This also checks that the range can extend beyond
// end of table
test_write_slice_contents(test_results, *table, offset, size);
if (offset + size > table_size)
break;
}
}
}
}
TEST(Table_Parent)
{
TableRef table = Table::create();
CHECK_EQUAL(TableRef(), table->get_parent_table());
CHECK_EQUAL(realm::npos, table->get_parent_row_index()); // Not a subtable
CHECK_EQUAL(realm::npos, table->get_index_in_group()); // Not a group-level table
DescriptorRef subdesc;
table->add_column(type_Table, "", &subdesc);
table->add_column(type_Mixed, "");
subdesc->add_column(type_Int, "");
table->add_empty_row(2);
table->set_mixed(1, 0, Mixed::subtable_tag());
table->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab;
size_t column_ndx = 0;
subtab = table->get_subtable(0,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after new
// column is insert.
table->insert_column(0, type_Int, "");
subtab = table->get_subtable(1,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(2,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(2,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after inserted
// column is removed.
table->remove_column(0);
subtab = table->get_subtable(0,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
}
TEST(Table_RegularSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
DescriptorRef subdesc;
parent->add_column(type_Table, "a", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
TableRef subtab_0_0 = parent->get_subtable(0,0);
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
parent->add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
subtab_0_0->add_empty_row();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
TableRef subtab_0_1 = parent->get_subtable(0,1);
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
TableRef subtab_1_0 = parent->get_subtable(1,0);
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
TableRef subtab_1_1 = parent->get_subtable(1,1);
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Float, "f");
subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int (0, 0, 10000);
subtab_0_0->set_float (1, 0, 10010.0f);
subtab_1_1->set_int (0, 0, 11100);
subtab_1_1->set_double (1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11100, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double (1,0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int (0, 0, 10001);
subtab_0_0->set_float (1, 0, 10011.0f);
subtab_1_1->set_int (0, 0, 11101);
subtab_1_1->set_double (1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11101, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
subtab_0_0->set_int (0, 0, 10002);
subtab_0_0->set_float (1, 0, 10012.0f);
subtab_1_1->set_int (0, 0, 11102);
subtab_1_1->set_double (1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11102, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int (0, 0, 10003);
subtab_0_0->set_float (1, 0, 10013.0f);
subtab_1_1->set_int (0, 0, 11103);
subtab_1_1->set_double (1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11103, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10004);
subtab_0_0->set_float (1, 0, 10014.0f);
subtab_1_1->set_int (0, 0, 11104);
subtab_1_1->set_double (1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11104, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int (0, 0, 10005);
subtab_0_0->set_float (1, 0, 10015.0f);
subtab_1_1->set_int (0, 0, 11105);
subtab_1_1->set_double (1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11105, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10006);
subtab_0_0->set_float (1, 0, 10016.0f);
subtab_1_1->set_int (0, 0, 11106);
subtab_1_1->set_double (1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11106, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int (0, 0, 10007);
subtab_0_0->set_float (1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK( subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
parent->remove_column(1);
subtab_0_0->set_int (0, 0, 10008);
subtab_0_0->set_float (1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
// Clear subtable
parent->clear_subtable(0,0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Table, "c", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0,0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK( subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Table, "d", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0,0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0,0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_MixedSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_column(type_Int, "x");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
subtab_0_0->add_empty_row();
parent->add_column(type_Mixed, "b");
parent->set_mixed(1, 0, Mixed::subtable_tag());
TableRef subtab_1_0 = parent->get_subtable(1,0);
subtab_1_0->add_column(type_Int, "x");
parent->add_empty_row();
parent->set_mixed(0, 1, Mixed::subtable_tag());
TableRef subtab_0_1 = parent->get_subtable(0,1);
subtab_0_1->add_column(type_Int, "x");
parent->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_column(type_Int, "x");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subtab_0_0->add_column(type_Float, "f");
subtab_0_1->add_column(type_Float, "f");
subtab_1_0->add_column(type_Double, "d");
subtab_1_1->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int (0, 0, 10000);
subtab_0_0->set_float (1, 0, 10010.0f);
subtab_1_1->set_int (0, 0, 11100);
subtab_1_1->set_double (1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11100, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double (1,0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int (0, 0, 10001);
subtab_0_0->set_float (1, 0, 10011.0f);
subtab_1_1->set_int (0, 0, 11101);
subtab_1_1->set_double (1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11101, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
parent->set_mixed(3, 2, "Lopadotemachoselachogaleokranioleipsanodrimhypotrimmatosilphio"
"paraomelitokatakechymenokichlepikossyphophattoperisteralektryonopte"
"kephalliokigklopeleiolagoiosiraiobaphetraganopterygon");
subtab_0_0->set_int (0, 0, 10002);
subtab_0_0->set_float (1, 0, 10012.0f);
subtab_1_1->set_int (0, 0, 11102);
subtab_1_1->set_double (1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11102, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int (0, 0, 10003);
subtab_0_0->set_float (1, 0, 10013.0f);
subtab_1_1->set_int (0, 0, 11103);
subtab_1_1->set_double (1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11103, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10004);
subtab_0_0->set_float (1, 0, 10014.0f);
subtab_1_1->set_int (0, 0, 11104);
subtab_1_1->set_double (1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11104, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int (0, 0, 10005);
subtab_0_0->set_float (1, 0, 10015.0f);
subtab_1_1->set_int (0, 0, 11105);
subtab_1_1->set_double (1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11105, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10006);
subtab_0_0->set_float (1, 0, 10016.0f);
subtab_1_1->set_int (0, 0, 11106);
subtab_1_1->set_double (1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11106, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int (0, 0, 10007);
subtab_0_0->set_float (1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK( subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
parent->remove_column(1);
subtab_0_0->set_int (0, 0, 10008);
subtab_0_0->set_float (1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
// Remove subtable
parent->clear_subtable(0,0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(!subtab_0_0->is_attached());
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Mixed, "c");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
CHECK(subtab_0_0);
CHECK(subtab_0_1);
CHECK(subtab_1_0);
CHECK(subtab_1_1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0,0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK( subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Mixed, "d");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0,0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0,0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_RowAccessor)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Int, "int");
table.add_column(type_Bool, "bool");
table.add_column(type_Float, "");
table.add_column(type_Double, "");
table.add_column(type_String, "");
table.add_column(type_Binary, "", true);
table.add_column(type_DateTime, "");
table.add_column(type_Table, "", &subdesc);
table.add_column(type_Mixed, "");
subdesc->add_column(type_Int, "i");
table.add_empty_row(2);
BinaryData bin("bin", 3);
Table empty_subtab;
empty_subtab.add_column(type_Int, "i");
Table one_subtab;
one_subtab.add_column(type_Int, "i");
one_subtab.add_empty_row(1);
one_subtab.set_int(0, 0, 19);
Table two_subtab;
two_subtab.add_column(type_Int, "i");
two_subtab.add_empty_row(1);
two_subtab.set_int(0, 0, 29);
table.set_int (0, 1, 4923);
table.set_bool (1, 1, true);
table.set_float (2, 1, 5298.0f);
table.set_double (3, 1, 2169.0);
table.set_string (4, 1, "str");
table.set_binary (5, 1, bin);
table.set_datetime (6, 1, 7739);
table.set_subtable (7, 1, &one_subtab);
table.set_mixed (8, 1, Mixed("mix"));
// Check getters for `RowExpr`
{
CHECK_EQUAL(9, table[0].get_column_count());
CHECK_EQUAL(type_Int, table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, table[0].get_column_type(1));
CHECK_EQUAL("int", table[0].get_column_name(0));
CHECK_EQUAL("bool", table[0].get_column_name(1));
CHECK_EQUAL(0, table[0].get_column_index("int"));
CHECK_EQUAL(1, table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), table[0].get_int (0));
CHECK_EQUAL(bool(), table[0].get_bool (1));
CHECK_EQUAL(float(), table[0].get_float (2));
CHECK_EQUAL(double(), table[0].get_double (3));
CHECK_EQUAL(StringData(""), table[0].get_string (4));
CHECK_EQUAL(BinaryData(), table[0].get_binary (5));
CHECK_EQUAL(DateTime(), table[0].get_datetime (6));
CHECK_EQUAL(0, table[0].get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), table[0].get_mixed (8));
CHECK_EQUAL(type_Int, table[0].get_mixed_type (8));
CHECK_EQUAL(4923, table[1].get_int (0));
CHECK_EQUAL(true, table[1].get_bool (1));
CHECK_EQUAL(5298.0f, table[1].get_float (2));
CHECK_EQUAL(2169.0, table[1].get_double (3));
CHECK_EQUAL("str", table[1].get_string (4));
CHECK_EQUAL(bin, table[1].get_binary (5));
CHECK_EQUAL(DateTime(7739), table[1].get_datetime (6));
CHECK_EQUAL(1, table[1].get_subtable_size (7));
CHECK_EQUAL("mix", table[1].get_mixed (8));
CHECK_EQUAL(type_String, table[1].get_mixed_type (8));
TableRef subtab_0 = table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRowExpr`
{
const Table& const_table = table;
CHECK_EQUAL(9, const_table[0].get_column_count());
CHECK_EQUAL(type_Int, const_table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, const_table[0].get_column_type(1));
CHECK_EQUAL("int", const_table[0].get_column_name(0));
CHECK_EQUAL("bool", const_table[0].get_column_name(1));
CHECK_EQUAL(0, const_table[0].get_column_index("int"));
CHECK_EQUAL(1, const_table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_int (0));
CHECK_EQUAL(bool(), const_table[0].get_bool (1));
CHECK_EQUAL(float(), const_table[0].get_float (2));
CHECK_EQUAL(double(), const_table[0].get_double (3));
CHECK_EQUAL(StringData(""), const_table[0].get_string (4));
CHECK_EQUAL(BinaryData(), const_table[0].get_binary (5));
CHECK_EQUAL(DateTime(), const_table[0].get_datetime (6));
CHECK_EQUAL(0, const_table[0].get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_mixed (8));
CHECK_EQUAL(type_Int, const_table[0].get_mixed_type (8));
CHECK_EQUAL(4923, const_table[1].get_int (0));
CHECK_EQUAL(true, const_table[1].get_bool (1));
CHECK_EQUAL(5298.0f, const_table[1].get_float (2));
CHECK_EQUAL(2169.0, const_table[1].get_double (3));
CHECK_EQUAL("str", const_table[1].get_string (4));
CHECK_EQUAL(bin, const_table[1].get_binary (5));
CHECK_EQUAL(DateTime(7739), const_table[1].get_datetime (6));
CHECK_EQUAL(1, const_table[1].get_subtable_size (7));
CHECK_EQUAL("mix", const_table[1].get_mixed (8));
CHECK_EQUAL(type_String, const_table[1].get_mixed_type (8));
ConstTableRef subtab_0 = const_table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = const_table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(9, row_0.get_column_count());
CHECK_EQUAL(type_Int, row_0.get_column_type(0));
CHECK_EQUAL(type_Bool, row_0.get_column_type(1));
CHECK_EQUAL("int", row_0.get_column_name(0));
CHECK_EQUAL("bool", row_0.get_column_name(1));
CHECK_EQUAL(0, row_0.get_column_index("int"));
CHECK_EQUAL(1, row_0.get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
TableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const Row`
{
const Row row_0 = table[0];
const Row row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRow`
{
ConstRow row_0 = table[0];
ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const ConstRow` (double constness)
{
const ConstRow row_0 = table[0];
const ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check setters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
row_0.set_int (0, 5651);
row_0.set_bool (1, true);
row_0.set_float (2, 8397.0f);
row_0.set_double (3, 1937.0);
row_0.set_string (4, "foo");
row_0.set_binary (5, bin);
row_0.set_datetime (6, DateTime(9992));
row_0.set_subtable (7, &one_subtab);
row_0.set_mixed (8, Mixed(3637.0f));
row_1.set_int (0, int_fast64_t());
row_1.set_bool (1, bool());
row_1.set_float (2, float());
row_1.set_double (3, double());
row_1.set_string (4, StringData(""));
row_1.set_binary (5, BinaryData());
row_1.set_datetime (6, DateTime());
row_1.set_subtable (7, 0);
row_1.set_mixed (8, Mixed());
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(5651, table.get_int (0,0));
CHECK_EQUAL(true, table.get_bool (1,0));
CHECK_EQUAL(8397.0f, table.get_float (2,0));
CHECK_EQUAL(1937.0, table.get_double (3,0));
CHECK_EQUAL("foo", table.get_string (4,0));
CHECK_EQUAL(bin, table.get_binary (5,0));
CHECK_EQUAL(DateTime(9992), table.get_datetime (6,0));
CHECK_EQUAL(3637.0f, table.get_mixed (8,0));
CHECK_EQUAL(int_fast64_t(), table.get_int (0,1));
CHECK_EQUAL(bool(), table.get_bool (1,1));
CHECK_EQUAL(float(), table.get_float (2,1));
CHECK_EQUAL(double(), table.get_double (3,1));
CHECK_EQUAL(StringData(""), table.get_string (4,1));
CHECK_EQUAL(BinaryData(), table.get_binary (5,1));
CHECK_EQUAL(DateTime(), table.get_datetime (6,1));
CHECK_EQUAL(int_fast64_t(), table.get_mixed (8,1));
TableRef subtab_0 = table.get_subtable(7,0);
CHECK_EQUAL(19, subtab_0->get_int(0,0));
CHECK(*subtab_0 == one_subtab);
TableRef subtab_1 = table.get_subtable(7,1);
CHECK(*subtab_1 == empty_subtab);
row_0.set_mixed_subtable(8, 0);
row_1.set_mixed_subtable(8, &two_subtab);
subtab_0 = table.get_subtable(8,0);
subtab_1 = table.get_subtable(8,1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK(*subtab_0 == Table());
CHECK_EQUAL(29, subtab_1->get_int(0,0));
CHECK(*subtab_1 == two_subtab);
}
// Check setters for `RowExpr`
{
table[0].set_int (0, int_fast64_t());
table[0].set_bool (1, bool());
table[0].set_float (2, float());
table[0].set_double (3, double());
table[0].set_string (4, StringData(""));
table[0].set_binary (5, BinaryData());
table[0].set_datetime (6, DateTime());
table[0].set_subtable (7, 0);
table[0].set_mixed (8, Mixed());
table[1].set_int (0, 5651);
table[1].set_bool (1, true);
table[1].set_float (2, 8397.0f);
table[1].set_double (3, 1937.0);
table[1].set_string (4, "foo");
table[1].set_binary (5, bin);
table[1].set_datetime (6, DateTime(9992));
table[1].set_subtable (7, &one_subtab);
table[1].set_mixed (8, Mixed(3637.0f));
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(int_fast64_t(), table.get_int (0,0));
CHECK_EQUAL(bool(), table.get_bool (1,0));
CHECK_EQUAL(float(), table.get_float (2,0));
CHECK_EQUAL(double(), table.get_double (3,0));
CHECK_EQUAL(StringData(""), table.get_string (4,0));
CHECK_EQUAL(BinaryData(), table.get_binary (5,0));
CHECK_EQUAL(DateTime(), table.get_datetime (6,0));
CHECK_EQUAL(int_fast64_t(), table.get_mixed (8,0));
CHECK_EQUAL(5651, table.get_int (0,1));
CHECK_EQUAL(true, table.get_bool (1,1));
CHECK_EQUAL(8397.0f, table.get_float (2,1));
CHECK_EQUAL(1937.0, table.get_double (3,1));
CHECK_EQUAL("foo", table.get_string (4,1));
CHECK_EQUAL(bin, table.get_binary (5,1));
CHECK_EQUAL(DateTime(9992), table.get_datetime (6,1));
CHECK_EQUAL(3637.0f, table.get_mixed (8,1));
TableRef subtab_0 = table.get_subtable(7,0);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table.get_subtable(7,1);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
table[0].set_mixed_subtable(8, &two_subtab);
table[1].set_mixed_subtable(8, 0);
subtab_0 = table.get_subtable(8,0);
subtab_1 = table.get_subtable(8,1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK_EQUAL(29, subtab_0->get_int(0,0));
CHECK(*subtab_0 == two_subtab);
CHECK(*subtab_1 == Table());
}
// Check that we can also create ConstRow's from `const Table`
{
const Table& const_table = table;
ConstRow row_0 = const_table[0];
ConstRow row_1 = const_table[1];
CHECK_EQUAL(0, row_0.get_int(0));
CHECK_EQUAL(5651, row_1.get_int(0));
}
// Check that we can get the table and the row index from a Row
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(&table, row_0.get_table());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
}
}
TEST(Table_RowAccessorLinks)
{
Group group;
TableRef target_table = group.add_table("target");
target_table->add_column(type_Int, "");
target_table->add_empty_row(16);
TableRef origin_table = group.add_table("origin");
origin_table->add_column_link(type_Link, "", *target_table);
origin_table->add_column_link(type_LinkList, "", *target_table);
origin_table->add_empty_row(2);
Row source_row_1 = origin_table->get(0);
Row source_row_2 = origin_table->get(1);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
// Set links
source_row_1.set_link(0, 7);
source_row_2.set_link(0, 13);
CHECK(!source_row_1.is_null_link(0));
CHECK(!source_row_2.is_null_link(0));
CHECK_EQUAL(7, source_row_1.get_link(0));
CHECK_EQUAL(13, source_row_2.get_link(0));
CHECK_EQUAL(1, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(7).get_backlink(*origin_table, 0, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink(*origin_table, 0, 0));
// Nullify links
source_row_1.nullify_link(0);
source_row_2.nullify_link(0);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
// Add stuff to link lists
LinkViewRef link_list_1 = source_row_1.get_linklist(1);
LinkViewRef link_list_2 = source_row_2.get_linklist(1);
link_list_1->add(15);
link_list_2->add(11);
link_list_2->add(15);
CHECK(!source_row_1.linklist_is_empty(1));
CHECK(!source_row_2.linklist_is_empty(1));
CHECK_EQUAL(1, source_row_1.get_link_count(1));
CHECK_EQUAL(2, source_row_2.get_link_count(1));
CHECK_EQUAL(1, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(2, target_table->get(15).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(1, target_table->get(11).get_backlink(*origin_table, 1, 0));
size_t back_link_1 = target_table->get(15).get_backlink(*origin_table, 1, 0);
size_t back_link_2 = target_table->get(15).get_backlink(*origin_table, 1, 1);
CHECK((back_link_1 == 0 && back_link_2 == 1) || (back_link_1 == 1 && back_link_2 == 0));
// Clear link lists
link_list_1->clear();
link_list_2->clear();
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
}
TEST(Table_RowAccessorDetach)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
Row row = table[0];
CHECK(row.is_attached());
row.detach();
CHECK(!row.is_attached());
row = table[0];
CHECK(row.is_attached());
}
TEST(Table_RowAccessorCopyAndAssign)
{
Table table;
const Table& ctable = table;
table.add_column(type_Int, "");
table.add_empty_row(3);
table.set_int(0, 0, 750);
table.set_int(0, 1, 751);
table.set_int(0, 2, 752);
{
// Check copy construction of row accessor from row expression
Row row_1 = table[0]; // Copy construct `Row` from `RowExpr`
ConstRow crow_1 = table[1]; // Copy construct `ConstRow` from `RowExpr`
ConstRow crow_2 = ctable[2]; // Copy construct `ConstRow` from `ConstRowExpr`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
// Check copy construction of row accessor from other row accessor
Row drow_1;
ConstRow dcrow_1;
CHECK(!drow_1.is_attached());
CHECK(!dcrow_1.is_attached());
Row drow_2 = drow_1; // Copy construct `Row` from detached `Row`
ConstRow dcrow_2 = drow_1; // Copy construct `ConstRow` from detached `Row`
ConstRow dcrow_3 = dcrow_1; // Copy construct `ConstRow` from detached `ConstRow`
Row row_2 = row_1; // Copy construct `Row` from attached `Row`
ConstRow crow_3 = row_1; // Copy construct `ConstRow` from attached `Row`
ConstRow crow_4 = crow_1; // Copy construct `ConstRow` from attached `ConstRow`
CHECK(!drow_2.is_attached());
CHECK(!dcrow_2.is_attached());
CHECK(!dcrow_3.is_attached());
CHECK(row_2.is_attached());
CHECK(crow_3.is_attached());
CHECK(crow_4.is_attached());
CHECK(!drow_2.get_table());
CHECK(!dcrow_2.get_table());
CHECK(!dcrow_3.get_table());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(&table, crow_4.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(0, crow_3.get_index());
CHECK_EQUAL(1, crow_4.get_index());
}
table.verify();
// Check assignment of row expression to row accessor
{
Row row;
ConstRow crow_1, crow_2;
row = table[0]; // Assign `RowExpr` to detached `Row`
crow_1 = table[1]; // Assign `RowExpr` to detached `ConstRow`
crow_2 = ctable[2]; // Assign `ConstRowExpr` to detached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row = table[1]; // Assign `RowExpr` to attached `Row`
crow_1 = table[2]; // Assign `RowExpr` to attached `ConstRow`
crow_2 = ctable[0]; // Assign `ConstRowExpr` to attached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(1, row.get_index());
CHECK_EQUAL(2, crow_1.get_index());
CHECK_EQUAL(0, crow_2.get_index());
}
// Check assignment of row accessor to row accessor
{
Row drow, row_1;
ConstRow dcrow, crow_1, crow_2;
row_1 = row_1; // Assign detached `Row` to self
crow_1 = crow_1; // Assign detached `ConstRow` to self
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
row_1 = drow; // Assign detached `Row` to detached `Row`
crow_1 = drow; // Assign detached `Row` to detached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to detached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
Row row_2 = table[0];
Row row_3 = table[1];
ConstRow crow_3 = table[2];
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK(crow_3.is_attached());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, row_3.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(1, row_3.get_index());
CHECK_EQUAL(2, crow_3.get_index());
row_1 = row_2; // Assign attached `Row` to detached `Row`
crow_1 = row_3; // Assign attached `Row` to detached `ConstRow`
crow_2 = crow_3; // Assign attached `ConstRow` to detached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row_1 = row_1; // Assign attached `Row` to self
crow_1 = crow_1; // Assign attached `ConstRow` to self
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
Row row_4 = table[2];
Row row_5 = table[0];
ConstRow crow_4 = table[1];
row_1 = row_4; // Assign attached `Row` to attached `Row`
crow_1 = row_5; // Assign attached `Row` to attached `ConstRow`
crow_2 = crow_4; // Assign attached `ConstRow` to attached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(0, crow_1.get_index());
CHECK_EQUAL(1, crow_2.get_index());
row_1 = drow; // Assign detached `Row` to attached `Row`
crow_1 = drow; // Assign detached `Row` to attached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to attached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
}
}
TEST(Table_RowAccessorCopyConstructionBug)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
BasicRowExpr<Table> row_expr(table[0]);
BasicRow<Table> row_from_expr(row_expr);
BasicRow<Table> row_copy(row_from_expr);
table.remove(0);
CHECK_NOT(row_from_expr.is_attached());
CHECK_NOT(row_copy.is_attached());
}
TEST(Table_RowAccessorAssignMultipleTables)
{
Table tables[2];
for (int i = 0; i < 2; ++i) {
tables[i].add_column(type_Int, "");
tables[i].add_empty_row(3);
tables[i].set_int(0, 0, 750);
tables[i].set_int(0, 1, 751);
tables[i].set_int(0, 2, 752);
}
Row row_1 = tables[0][2];
Row row_2 = tables[1][2];
Row row_3 = tables[0][2];
row_1 = tables[1][2]; // Assign attached `Row` to a different table via RowExpr
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 2);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 1);
row_1 = row_3; // Assign attached `Row` to a different table via Row
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 0);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 0);
}
TEST(Table_RowAccessorRetain)
{
// Create a table with two rows
TableRef parent = Table::create();
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
ConstRow row_1 = (*parent)[0];
ConstRow row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that row insertion does not detach the row accessors, and that the
// row indexes is properly adjusted
parent->insert_empty_row(1); // Between
parent->add_empty_row(); // After
parent->insert_empty_row(0); // Before
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->insert_empty_row(1); // Immediately before row_1
parent->insert_empty_row(5); // Immediately after row_2
parent->insert_empty_row(3); // Immediately after row_1
parent->insert_empty_row(5); // Immediately before row_2
parent->verify();
CHECK_EQUAL(9, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(6, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of rows (other than row_1 and row_2) does not detach
// the row accessors, and that the row indexes is properly adjusted
parent->remove(3); // Immediately after row_1
parent->remove(1); // Immediately before row_1
parent->remove(3); // Immediately before row_2
parent->remove(4); // Immediately after row_2
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->remove(4); // After
parent->remove(0); // Before
parent->remove(1); // Between
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of first row detaches row_1
parent->remove(0);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(!row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(227, row_2.get_int(0));
// Restore first row and recover row_1
parent->insert_empty_row(0);
parent->set_int(0, 0, 27);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of second row detaches row_2
parent->remove(1);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(row_1.is_attached());
CHECK(!row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
// Restore second row and recover row_2
parent->add_empty_row();
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that descriptor modifications do not affect the row accessors (as
// long as we do not remove the last column)
parent->add_column(type_String, "x");
parent->insert_column(0, type_Float, "y");
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(1));
CHECK_EQUAL(227, row_2.get_int(1));
parent->remove_column(0);
parent->remove_column(1);
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of the last column detaches all row accessors
parent->remove_column(0);
parent->verify();
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
// Restore rows and recover row accessors
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that clearing of the table detaches all row accessors
parent->clear();
parent->verify();
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
}
TEST(Table_SubtableRowAccessorsRetain)
{
// Create a mixed and a regular subtable each with one row
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_column(type_Table, "b");
DescriptorRef subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(0,0);
CHECK(mixed && mixed->is_attached());
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
TableRef regular = parent->get_subtable(1,0);
CHECK(regular && regular->is_attached());
regular->add_empty_row();
regular->set_int(0, 0, 29);
CHECK(mixed->size() == 1);
CHECK(regular->size() == 1);
ConstRow row_m = (*mixed)[0];
ConstRow row_r = (*regular)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a mixed subtable are detached if the
// subtable is overridden
parent->set_mixed(0, 0, Mixed("foo"));
CHECK(!mixed->is_attached());
CHECK(regular->is_attached());
CHECK(!row_m.is_attached());
CHECK(row_r.is_attached());
// Restore mixed
parent->set_mixed(0, 0, Mixed::subtable_tag());
mixed = parent->get_subtable(0,0);
CHECK(mixed);
CHECK(mixed->is_attached());
mixed->add_column(type_Int, "mixed_2");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
CHECK(regular->is_attached());
CHECK_EQUAL(1, mixed->size());
CHECK_EQUAL(1, regular->size());
row_m = (*mixed)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a regular subtable are detached if the
// subtable is overridden
parent->set_subtable(1, 0, 0); // Clear
CHECK(mixed->is_attached());
CHECK(regular->is_attached());
CHECK(row_m.is_attached());
CHECK(!row_r.is_attached());
}
TEST(Table_MoveLastOverRetain)
{
// Create three parent tables, each with with 5 rows, and each row
// containing one regular and one mixed subtable
TableRef parent_1, parent_2, parent_3;
for (int i = 0; i < 3; ++i) {
TableRef& parent = i == 0 ? parent_1 : i == 1 ? parent_2 : parent_3;
parent = Table::create();
parent->add_column(type_Table, "a");
parent->add_column(type_Mixed, "b");
DescriptorRef subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row(5);
for (int row_ndx = 0; row_ndx < 5; ++row_ndx) {
TableRef regular = parent->get_subtable(0, row_ndx);
regular->add_empty_row();
regular->set_int(0, 0, 10 + row_ndx);
parent->set_mixed(1, row_ndx, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(1, row_ndx);
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 20 + row_ndx);
}
}
// Use first table to check with accessors on row indexes 0, 1, and 4, but
// none at index 2 and 3.
{
TableRef parent = parent_1;
ConstRow row_0 = (*parent)[0];
ConstRow row_1 = (*parent)[1];
ConstRow row_4 = (*parent)[4];
TableRef regular_0 = parent->get_subtable(0,0);
TableRef regular_1 = parent->get_subtable(0,1);
TableRef regular_4 = parent->get_subtable(0,4);
TableRef mixed_0 = parent->get_subtable(1,0);
TableRef mixed_1 = parent->get_subtable(1,1);
TableRef mixed_4 = parent->get_subtable(1,4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(4, row_4.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0,0));
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(14, regular_4->get_int(0,0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_4 && mixed_4->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0,0));
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(24, mixed_4->get_int(0,0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(2, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(14, regular_4->get_int(0,0));
CHECK_EQUAL(regular_1, parent->get_subtable(0,1));
CHECK_EQUAL(regular_4, parent->get_subtable(0,2));
CHECK(!mixed_0->is_attached());
CHECK(mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(24, mixed_4->get_int(0,0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1,1));
CHECK_EQUAL(mixed_4, parent->get_subtable(1,2));
// Perform two more 'move last over' operations which brings the number
// of rows down from 3 to 1
parent->move_last_over(1); // Move row at index 2 to index 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(14, regular_4->get_int(0,0));
CHECK_EQUAL(regular_4, parent->get_subtable(0,0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(24, mixed_4->get_int(0,0));
CHECK_EQUAL(mixed_4, parent->get_subtable(1,0));
}
// Use second table to check with accessors on row indexes 0, 2, and 3, but
// none at index 1 and 4.
{
TableRef parent = parent_2;
ConstRow row_0 = (*parent)[0];
ConstRow row_2 = (*parent)[2];
ConstRow row_3 = (*parent)[3];
TableRef regular_0 = parent->get_subtable(0,0);
TableRef regular_2 = parent->get_subtable(0,2);
TableRef regular_3 = parent->get_subtable(0,3);
TableRef mixed_0 = parent->get_subtable(1,0);
TableRef mixed_2 = parent->get_subtable(1,2);
TableRef mixed_3 = parent->get_subtable(1,3);
CHECK(row_0.is_attached());
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(2, row_2.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0,0));
CHECK_EQUAL(12, regular_2->get_int(0,0));
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_2 && mixed_2->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0,0));
CHECK_EQUAL(22, mixed_2->get_int(0,0));
CHECK_EQUAL(23, mixed_3->get_int(0,0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(!mixed_3->is_attached());
}
// Use third table to check with accessors on row indexes 1 and 3, but none
// at index 0, 2, and 4.
{
TableRef parent = parent_3;
ConstRow row_1 = (*parent)[1];
ConstRow row_3 = (*parent)[3];
TableRef regular_1 = parent->get_subtable(0,1);
TableRef regular_3 = parent->get_subtable(0,3);
TableRef mixed_1 = parent->get_subtable(1,1);
TableRef mixed_3 = parent->get_subtable(1,3);
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(23, mixed_3->get_int(0,0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(0, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_1, parent->get_subtable(0,1));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1,1));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(!mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_1.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_1->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(!mixed_3->is_attached());
}
}
TEST(Table_EnumStringInsertEmptyRow)
{
Table table;
table.add_column(type_String, "");
table.add_empty_row(128);
for (int i = 0; i < 128; ++i)
table.set_string(0, i, "foo");
DescriptorRef desc = table.get_descriptor();
CHECK_EQUAL(0, desc->get_num_unique_values(0));
table.optimize();
// Make sure we now have an enumerated strings column
CHECK_EQUAL(1, desc->get_num_unique_values(0));
table.add_empty_row();
CHECK_EQUAL("", table.get_string(0, 128));
}
TEST(Table_AddColumnWithThreeLevelBptree)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE*REALM_MAX_BPNODE_SIZE+1);
table.add_column(type_Int, "");
table.verify();
}
TEST(Table_ClearWithTwoLevelBptree)
{
Table table;
table.add_column(type_Mixed, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE+1);
table.clear();
table.verify();
}
TEST(Table_IndexStringDelete)
{
Table t;
t.add_column(type_String, "str");
t.add_search_index(0);
std::ostringstream out;
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
out.str(std::string());
out << i;
t.set_string(0, i, out.str());
}
t.clear();
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
out.str(std::string());
out << i;
t.set_string(0, i, out.str());
}
}
#if REALM_NULL_STRINGS == 1
TEST(Table_Nulls)
{
// 'round' lets us run this entire test both with and without index and with/without optimize/enum
for (size_t round = 0; round < 5; round++) {
Table t;
TableView tv;
t.add_column(type_String, "str", true /*nullable*/ );
if (round == 1)
t.add_search_index(0);
else if (round == 2)
t.optimize(true);
else if (round == 3) {
t.add_search_index(0);
t.optimize(true);
}
else if (round == 4) {
t.optimize(true);
t.add_search_index(0);
}
t.add_empty_row(3);
t.set_string(0, 0, "foo"); // short strings
t.set_string(0, 1, "");
t.set_string(0, 2, realm::null());
CHECK_EQUAL(1, t.count_string(0, "foo"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "foo"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "foo");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYY"); // medium strings (< 64)
CHECK_EQUAL(1, t.count_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYY");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
// long strings (>= 64)
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, t.count_string(0,
"xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0,
"xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
}
{
Table t;
t.add_column(type_Int, "int", true); // nullable = true
t.add_column(type_Bool, "bool", true); // nullable = true
t.add_column(type_DateTime, "bool", true); // nullable = true
t.add_empty_row(2);
t.set_int(0, 0, 65);
t.set_bool(1, 0, false);
t.set_datetime(2, 0, DateTime(3));
CHECK_EQUAL(65, t.get_int(0, 0));
CHECK_EQUAL(false, t.get_bool(1, 0));
CHECK_EQUAL(DateTime(3), t.get_datetime(2, 0));
CHECK_EQUAL(65, t.maximum_int(0));
CHECK_EQUAL(65, t.minimum_int(0));
CHECK_EQUAL(DateTime(3), t.maximum_datetime(2));
CHECK_EQUAL(DateTime(3), t.minimum_datetime(2));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(!t.is_null(2, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK(t.is_null(2, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(1, t.find_first_null(2));
CHECK_EQUAL(not_found, t.find_first_int(0, -1));
CHECK_EQUAL(not_found, t.find_first_bool(1, true));
CHECK_EQUAL(not_found, t.find_first_datetime(2, DateTime(5)));
CHECK_EQUAL(0, t.find_first_int(0, 65));
CHECK_EQUAL(0, t.find_first_bool(1, false));
CHECK_EQUAL(0, t.find_first_datetime(2, DateTime(3)));
t.set_null(0, 0);
t.set_null(1, 0);
t.set_null(2, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
CHECK(t.is_null(2, 0));
}
{
Table t;
t.add_column(type_Float, "float", true); // nullable = true
t.add_column(type_Double, "double", true); // nullable = true
t.add_empty_row(2);
t.set_float(0, 0, 1.23f);
t.set_double(1, 0, 12.3);
CHECK_EQUAL(1.23f, t.get_float(0, 0));
CHECK_EQUAL(12.3, t.get_double(1, 0));
CHECK_EQUAL(1.23f, t.maximum_float(0));
CHECK_EQUAL(1.23f, t.minimum_float(0));
CHECK_EQUAL(12.3, t.maximum_double(1));
CHECK_EQUAL(12.3, t.minimum_double(1));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(not_found, t.find_first_float(0, 2.22f));
CHECK_EQUAL(not_found, t.find_first_double(1, 2.22));
CHECK_EQUAL(0, t.find_first_float(0, 1.23f));
CHECK_EQUAL(0, t.find_first_double(1, 12.3));
t.set_null(0, 0);
t.set_null(1, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
}
}
#endif
TEST(Table_RowAccessor_Null)
{
Table table;
size_t col_bool = table.add_column(type_Bool, "bool", true);
size_t col_int = table.add_column(type_Int, "int", true);
size_t col_string = table.add_column(type_String, "string", true);
size_t col_float = table.add_column(type_Float, "float", true);
size_t col_double = table.add_column(type_Double, "double", true);
size_t col_date = table.add_column(type_DateTime, "date", true);
size_t col_binary = table.add_column(type_Binary, "binary", true);
{
table.add_empty_row();
Row row = table[0];
row.set_null(col_bool);
row.set_null(col_int);
row.set_string(col_string, realm::null());
row.set_null(col_float);
row.set_null(col_double);
row.set_null(col_date);
row.set_binary(col_binary, BinaryData());
}
{
table.add_empty_row();
Row row = table[1];
row.set_bool(col_bool, true);
row.set_int(col_int, 1);
row.set_string(col_string, "1");
row.set_float(col_float, 1.0);
row.set_double(col_double, 1.0);
row.set_datetime(col_date, DateTime(1));
row.set_binary(col_binary, BinaryData("a"));
}
{
Row row = table[0];
CHECK(row.is_null(col_bool));
CHECK(row.is_null(col_int));
CHECK(row.is_null(col_string));
CHECK(row.is_null(col_float));
CHECK(row.is_null(col_double));
CHECK(row.is_null(col_date));
CHECK(row.is_null(col_binary));
}
{
Row row = table[1];
CHECK_EQUAL(true, row.get_bool(col_bool));
CHECK_EQUAL(1, row.get_int(col_int));
CHECK_EQUAL("1", row.get_string(col_string));
CHECK_EQUAL(1.0, row.get_float(col_float));
CHECK_EQUAL(1.0, row.get_double(col_double));
CHECK_EQUAL(DateTime(1), row.get_datetime(col_date));
CHECK_EQUAL(BinaryData("a"), row.get_binary(col_binary));
}
}
// This triggers a severe bug in the Array::alloc() allocator in which its capacity-doubling
// scheme forgets to test of the doubling has overflowed the maximum allowed size of an
// array which is 2^20 - 1 bytes
TEST(Table_AllocatorCapacityBug)
{
char* buf = new char[20000000];
// First a simple trigger of `Assertion failed: value <= 0xFFFFFL [26000016, 16777215]`
{
ref_type ref = BinaryColumn::create(Allocator::get_default());
BinaryColumn c(Allocator::get_default(), ref, true);
c.add(BinaryData(buf, 13000000));
c.set(0, BinaryData(buf, 14000000));
}
// Now a small fuzzy test to catch other such bugs
{
Table t;
t.add_column(type_Binary, "", true);
for (size_t j = 0; j < 100; j++) {
size_t r = (j * 123456789 + 123456789) % 100;
if (r < 20) {
t.add_empty_row();
}
else if (t.size() > 0 && t.size() < 5) {
// Set only if there are no more than 4 rows, else it takes up too much space on devices (4 * 16 MB
// worst case now)
size_t row = (j * 123456789 + 123456789) % t.size();
size_t len = (j * 123456789 + 123456789) % 16000000;
BinaryData bd;
bd = BinaryData(buf, len);
t.set_binary(0, row, bd);
}
else if (t.size() >= 4) {
t.clear();
}
}
delete buf;
}
}
#endif // TEST_TABLE
Update test_table.cpp
#include "testsettings.hpp"
#ifdef TEST_TABLE
#include <algorithm>
#include <limits>
#include <string>
#include <fstream>
#include <ostream>
#include <realm.hpp>
#include <realm/lang_bind_helper.hpp>
#include <realm/util/buffer.hpp>
#include "util/misc.hpp"
#include "test.hpp"
using namespace realm;
using namespace realm::util;
using namespace realm::test_util;
using unit_test::TestResults;
// Test independence and thread-safety
// -----------------------------------
//
// All tests must be thread safe and independent of each other. This
// is required because it allows for both shuffling of the execution
// order and for parallelized testing.
//
// In particular, avoid using std::rand() since it is not guaranteed
// to be thread safe. Instead use the API offered in
// `test/util/random.hpp`.
//
// All files created in tests must use the TEST_PATH macro (or one of
// its friends) to obtain a suitable file system path. See
// `test/util/test_path.hpp`.
//
//
// Debugging and the ONLY() macro
// ------------------------------
//
// A simple way of disabling all tests except one called `Foo`, is to
// replace TEST(Foo) with ONLY(Foo) and then recompile and rerun the
// test suite. Note that you can also use filtering by setting the
// environment varible `UNITTEST_FILTER`. See `README.md` for more on
// this.
//
// Another way to debug a particular test, is to copy that test into
// `experiments/testcase.cpp` and then run `sh build.sh
// check-testcase` (or one of its friends) from the command line.
namespace {
REALM_TABLE_2(TupleTableType,
first, Int,
second, String)
} // anonymous namespace
#ifdef JAVA_MANY_COLUMNS_CRASH
REALM_TABLE_3(SubtableType,
year, Int,
daysSinceLastVisit, Int,
conceptId, String)
REALM_TABLE_7(MainTableType,
patientId, String,
gender, Int,
ethnicity, Int,
yearOfBirth, Int,
yearOfDeath, Int,
zipCode, String,
events, Subtable<SubtableType>)
TEST(Table_ManyColumnsCrash2)
{
// Trying to reproduce Java crash.
for (int a = 0; a < 10; a++)
{
Group group;
MainTableType::Ref mainTable = group.add_table<MainTableType>("PatientTable");
TableRef dynPatientTable = group.add_table("PatientTable");
dynPatientTable->add_empty_row();
for (int counter = 0; counter < 20000; counter++)
{
#if 0
// Add row to subtable through typed interface
SubtableType::Ref subtable = mainTable[0].events->get_table_ref();
REALM_ASSERT(subtable->is_attached());
subtable->add(0, 0, "");
REALM_ASSERT(subtable->is_attached());
#else
// Add row to subtable through dynamic interface. This mimics Java closest
TableRef subtable2 = dynPatientTable->get_subtable(6, 0);
REALM_ASSERT(subtable2->is_attached());
size_t subrow = subtable2->add_empty_row();
REALM_ASSERT(subtable2->is_attached());
#endif
if((counter % 1000) == 0){
// std::cerr << counter << "\n";
}
}
}
}
#endif // JAVA_MANY_COLUMNS_CRASH
TEST(Table_Null)
{
{
// Check that add_empty_row() adds NULL string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name", true); // nullable = true
table->add_empty_row();
CHECK(table->get_string(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
table->add_empty_row();
CHECK(!table->get_string(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_string(0, 0, realm::null()), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds null integer as default
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "name", true /*nullable*/);
table->add_empty_row();
CHECK(table->is_null(0, 0));
}
{
// Check that add_empty_row() adds 0 integer as default.
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Int, "name");
table->add_empty_row();
CHECK(!table->is_null(0, 0));
CHECK_EQUAL(0, table->get_int(0, 0));
// Check that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_null(0, 0), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds NULL binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name", true /*nullable*/);
table->add_empty_row();
CHECK(table->get_binary(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name");
table->add_empty_row();
CHECK(!table->get_binary(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_THROW_ANY(table->set_binary(0, 0, BinaryData()));
}
}
TEST(Table_DeleteCrash)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
table->add_column(type_Int, "age");
table->add_empty_row(3);
table->set_string(0, 0, "Alice");
table->set_int(1, 0, 27);
table->set_string(0, 1, "Bob");
table->set_int(1, 1, 50);
table->set_string(0, 2, "Peter");
table->set_int(1, 2, 44);
table->remove(0);
table->remove(1);
}
TEST(Table_OptimizeCrash)
{
// This will crash at the .add() method
TupleTableType ttt;
ttt.optimize();
ttt.column().second.add_search_index();
ttt.clear();
ttt.add(1, "AA");
}
TEST(Table_1)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Int, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_int(1, ndx, 10);
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(10, table.get_int(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_int(0, i, 2*i);
table.set_int(1, i, 20*i);
}
for (size_t i = ndx; i < 7; ++i) {
const int64_t v1 = 2 * i;
const int64_t v2 = 20 * i;
CHECK_EQUAL(v1, table.get_int(0, i));
CHECK_EQUAL(v2, table.get_int(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_ColumnNameTooLong)
{
Group group;
TableRef table = group.add_table("foo");
const size_t buf_size = 64;
std::unique_ptr<char[]> buf(new char[buf_size]);
CHECK_LOGIC_ERROR(table->add_column(type_Int, StringData(buf.get(), buf_size)),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column(0, type_Int, StringData(buf.get(), buf_size)),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->add_column_link(type_Link,
StringData(buf.get(), buf_size),
*table),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column_link(0, type_Link,
StringData(buf.get(), buf_size),
*table),
LogicError::column_name_too_long);
table->add_column(type_Int, StringData(buf.get(), buf_size - 1));
table->insert_column(0, type_Int, StringData(buf.get(), buf_size - 1));
table->add_column_link(type_Link, StringData(buf.get(), buf_size - 1), *table);
table->insert_column_link(0, type_Link, StringData(buf.get(), buf_size - 1), *table);
}
TEST(Table_StringOrBinaryTooBig)
{
Table table;
table.add_column(type_String, "s");
table.add_column(type_Binary, "b");
table.add_column(type_Mixed, "m1");
table.add_column(type_Mixed, "m2");
table.add_empty_row();
table.set_string(0, 0, "01234567");
size_t large_bin_size = 0xFFFFF1;
size_t large_str_size = 0xFFFFF0; // null-terminate reduces max size by 1
std::unique_ptr<char[]> large_buf(new char[large_bin_size]);
CHECK_LOGIC_ERROR(table.set_string(0, 0, StringData(large_buf.get(), large_str_size)),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size)),
LogicError::binary_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size))),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size))),
LogicError::binary_too_big);
table.set_string(0, 0, StringData(large_buf.get(), large_str_size - 1));
table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size - 1));
table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size - 1)));
table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size - 1)));
}
TEST(Table_Floats)
{
Table table;
table.add_column(type_Float, "first");
table.add_column(type_Double, "second");
CHECK_EQUAL(type_Float, table.get_column_type(0));
CHECK_EQUAL(type_Double, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_float(0, ndx, float(1.12));
table.set_double(1, ndx, double(102.13));
CHECK_EQUAL(float(1.12), table.get_float(0, ndx));
CHECK_EQUAL(double(102.13), table.get_double(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_float(0, i, float(1.12) + 100*i);
table.set_double(1, i, double(102.13)*200*i);
}
for (size_t i = ndx; i < 7; ++i) {
const float v1 = float(1.12) + 100*i;
const double v2 = double(102.13)*200*i;
CHECK_EQUAL(v1, table.get_float(0, i));
CHECK_EQUAL(v2, table.get_double(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
REALM_TABLE_4(TestTable,
first, Int,
second, Int,
third, Bool,
fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_2)
{
TestTable table;
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL(0, r.first);
CHECK_EQUAL(10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL(Wed, r.fourth);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_3)
{
TestTable table;
for (size_t i = 0; i < 100; ++i) {
table.add(0, 10, true, Wed);
}
// Test column searching
CHECK_EQUAL(size_t(0), table.column().first.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().first.find_first(1));
CHECK_EQUAL(size_t(0), table.column().second.find_first(10));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(100));
CHECK_EQUAL(size_t(0), table.column().third.find_first(true));
CHECK_EQUAL(size_t(-1), table.column().third.find_first(false));
CHECK_EQUAL(size_t(0) , table.column().fourth.find_first(Wed));
CHECK_EQUAL(size_t(-1), table.column().fourth.find_first(Mon));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableEnum,
first, Enum<Days>,
second, String)
} // anonymous namespace
TEST(Table_4)
{
TestTableEnum table;
table.add(Mon, "Hello");
table.add(Mon, "HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello");
const TestTableEnum::Cursor r = table.back(); // last item
CHECK_EQUAL(Mon, r.first);
CHECK_EQUAL("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello", r.second);
// Test string column searching
CHECK_EQUAL(size_t(1), table.column().second.find_first("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello"));
CHECK_EQUAL(size_t(-1), table.column().second.find_first("Foo"));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableFloats,
first, Float,
second, Double)
} // anonymous namespace
TEST(Table_Float2)
{
TestTableFloats table;
table.add(1.1f, 2.2);
table.add(1.1f, 2.2);
const TestTableFloats::Cursor r = table.back(); // last item
CHECK_EQUAL(1.1f, r.first);
CHECK_EQUAL(2.2, r.second);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Delete)
{
TestTable table;
for (size_t i = 0; i < 10; ++i) {
table.add(0, i, true, Wed);
}
table.remove(0);
table.remove(4);
table.remove(7);
CHECK_EQUAL(1, table[0].second);
CHECK_EQUAL(2, table[1].second);
CHECK_EQUAL(3, table[2].second);
CHECK_EQUAL(4, table[3].second);
CHECK_EQUAL(6, table[4].second);
CHECK_EQUAL(7, table[5].second);
CHECK_EQUAL(8, table[6].second);
#ifdef REALM_DEBUG
table.verify();
#endif
// Delete all items one at a time
for (size_t i = 0; i < 7; ++i) {
table.remove(0);
}
CHECK(table.is_empty());
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_GetName)
{
// Freestanding tables have no names
{
Table table;
CHECK_EQUAL("", table.get_name());
}
// ... regardless of how they are created
{
TableRef table = Table::create();
CHECK_EQUAL("", table->get_name());
}
// Direct members of groups do have names
{
Group group;
TableRef table = group.add_table("table");
CHECK_EQUAL("table", table->get_name());
}
{
Group group;
TableRef foo = group.add_table("foo");
TableRef bar = group.add_table("bar");
CHECK_EQUAL("foo", foo->get_name());
CHECK_EQUAL("bar", bar->get_name());
}
// Subtables should never have names
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "sub", &subdesc);
table.add_empty_row();
TableRef subtab = table.get_subtable(0,0);
CHECK_EQUAL("", table.get_name());
CHECK_EQUAL("", subtab->get_name());
}
// ... not even when the parent is a member of a group
{
Group group;
TableRef table = group.add_table("table");
DescriptorRef subdesc;
table->add_column(type_Table, "sub", &subdesc);
table->add_empty_row();
TableRef subtab = table->get_subtable(0,0);
CHECK_EQUAL("table", table->get_name());
CHECK_EQUAL("", subtab->get_name());
}
}
namespace {
void setup_multi_table(Table& table, size_t rows, size_t sub_rows,
bool fixed_subtab_sizes = false)
{
// Create table with all column types
{
DescriptorRef sub1;
table.add_column(type_Int, "int"); // 0
table.add_column(type_Bool, "bool"); // 1
table.add_column(type_DateTime, "date"); // 2
table.add_column(type_Float, "float"); // 3
table.add_column(type_Double, "double"); // 4
table.add_column(type_String, "string"); // 5
table.add_column(type_String, "string_long"); // 6
table.add_column(type_String, "string_big_blobs"); // 7
table.add_column(type_String, "string_enum"); // 8 - becomes StringEnumColumn
table.add_column(type_Binary, "binary"); // 9
table.add_column(type_Table, "tables", &sub1); // 10
table.add_column(type_Mixed, "mixed"); // 11
table.add_column(type_Int, "int_null", true); // 12, nullable = true
sub1->add_column(type_Int, "sub_first");
sub1->add_column(type_String, "sub_second");
}
table.add_empty_row(rows);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
table.set_int(0, i, int64_t(i*sign));
if (i % 4 == 0) {
table.set_null(12, i);
}
else {
table.set_int(12, i, int64_t(i*sign));
}
}
for (size_t i = 0; i < rows; ++i)
table.set_bool(1, i, (i % 2 ? true : false));
for (size_t i = 0; i < rows; ++i)
table.set_datetime(2, i, 12345);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
table.set_float(3, i, 123.456f*sign);
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
table.set_double(4, i, 9876.54321*sign);
}
std::vector<std::string> strings;
for (size_t i = 0; i < rows; ++i) {
std::stringstream out;
out << "string" << i;
strings.push_back(out.str());
}
for (size_t i = 0; i < rows; ++i)
table.set_string(5, i, strings[i]);
for (size_t i = 0; i < rows; ++i)
table.set_string(6, i, strings[i] + " very long string.........");
for (size_t i = 0; i < rows; ++i) {
switch (i % 2) {
case 0: {
std::string s = strings[i];
s += " very long string.........";
for (int j = 0; j != 4; ++j)
s += " big blobs big blobs big blobs"; // +30
table.set_string(7, i, s);
break;
}
case 1:
table.set_string(7, i, "");
break;
}
}
for (size_t i = 0; i < rows; ++i) {
switch (i % 3) {
case 0:
table.set_string(8, i, "enum1");
break;
case 1:
table.set_string(8, i, "enum2");
break;
case 2:
table.set_string(8, i, "enum3");
break;
}
}
for (size_t i = 0; i < rows; ++i)
table.set_binary(9, i, BinaryData("binary", 7));
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
size_t n = sub_rows;
if (!fixed_subtab_sizes)
n += i;
for (size_t j = 0; j != n; ++j) {
TableRef subtable = table.get_subtable(10, i);
int64_t val = -123+i*j*1234*sign;
subtable->insert_empty_row(j);
subtable->set_int(0, j, val);
subtable->set_string(1, j, "sub");
}
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i%2 == 0) ? 1 : -1;
switch (i % 8) {
case 0:
table.set_mixed(11, i, false);
break;
case 1:
table.set_mixed(11, i, int64_t(i*i*sign));
break;
case 2:
table.set_mixed(11, i, "string");
break;
case 3:
table.set_mixed(11, i, DateTime(123456789));
break;
case 4:
table.set_mixed(11, i, BinaryData("binary", 7));
break;
case 5: {
// Add subtable to mixed column
// We can first set schema and contents when the entire
// row has been inserted
table.set_mixed(11, i, Mixed::subtable_tag());
TableRef subtable = table.get_subtable(11, i);
subtable->add_column(type_Int, "first");
subtable->add_column(type_String, "second");
for (size_t j = 0; j != 2; ++j) {
subtable->insert_empty_row(j);
subtable->set_int(0, j, i*i*j*sign);
subtable->set_string(1, j, "mixed sub");
}
break;
}
case 6:
table.set_mixed(11, i, float(123.1*i*sign));
break;
case 7:
table.set_mixed(11, i, double(987.65*i*sign));
break;
}
}
// We also want a StringEnumColumn
table.optimize();
}
} // anonymous namespace
TEST(Table_LowLevelCopy)
{
Table table;
setup_multi_table(table, 15, 2);
#ifdef REALM_DEBUG
table.verify();
#endif
Table table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TableRef table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_HighLevelCopy)
{
TestTable table;
table.add(10, 120, false, Mon);
table.add(12, 100, true, Tue);
#ifdef REALM_DEBUG
table.verify();
#endif
TestTable table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TestTable::Ref table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_DeleteAllTypes)
{
Table table;
setup_multi_table(table, 15, 2);
// Test Deletes
table.remove(14);
table.remove(0);
table.remove(5);
CHECK_EQUAL(12, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
// Test Clear
table.clear();
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
// Triggers a bug that would make Realm crash if you run optimize() followed by add_search_index()
TEST(Table_Optimize_SetIndex_Crash)
{
Table table;
table.add_column(type_String, "first");
table.add_empty_row(3);
table.set_string(0, 0, "string0");
table.set_string(0, 1, "string1");
table.set_string(0, 2, "string1");
table.optimize();
CHECK_NOT_EQUAL(0, table.get_descriptor()->get_num_unique_values(0));
table.set_string(0, 2, "string2");
table.add_search_index(0);
table.move_last_over(1);
table.move_last_over(1);
}
TEST(Table_MoveAllTypes)
{
Random random(random_int<unsigned long>()); // Seed from slow global generator
Table table;
setup_multi_table(table, 15, 2);
table.add_search_index(6);
while (!table.is_empty()) {
size_t size = table.size();
size_t target_row_ndx = random.draw_int_mod(size);
table.move_last_over(target_row_ndx);
table.verify();
}
}
TEST(Table_DegenerateSubtableSearchAndAggregate)
{
Table parent;
// Add all column types
{
DescriptorRef sub_1, sub_2;
parent.add_column(type_Table, "child", &sub_1);
sub_1->add_column(type_Int, "int"); // 0
sub_1->add_column(type_Bool, "bool"); // 1
sub_1->add_column(type_Float, "float"); // 2
sub_1->add_column(type_Double, "double"); // 3
sub_1->add_column(type_DateTime, "date"); // 4
sub_1->add_column(type_String, "string"); // 5
sub_1->add_column(type_Binary, "binary"); // 6
sub_1->add_column(type_Table, "table", &sub_2); // 7
sub_1->add_column(type_Mixed, "mixed"); // 8
sub_1->add_column(type_Int, "int_null", nullptr, true); // 9, nullable = true
sub_2->add_column(type_Int, "i");
}
parent.add_empty_row(); // Create a degenerate subtable
ConstTableRef degen_child = parent.get_subtable(0,0); // NOTE: Constness is essential here!!!
CHECK_EQUAL(0, degen_child->size());
CHECK_EQUAL(10, degen_child->get_column_count());
// Searching:
CHECK_LOGIC_ERROR(degen_child->find_pkey_string(""), LogicError::no_primary_key);
// CHECK_EQUAL(0, degen_child->distinct(0).size()); // needs index but you cannot set index on ConstTableRef
CHECK_EQUAL(0, degen_child->get_sorted_view(0).size());
CHECK_EQUAL(not_found, degen_child->find_first_int(0, 0));
CHECK_EQUAL(not_found, degen_child->find_first_bool(1, false));
CHECK_EQUAL(not_found, degen_child->find_first_float(2, 0));
CHECK_EQUAL(not_found, degen_child->find_first_double(3, 0));
CHECK_EQUAL(not_found, degen_child->find_first_datetime(4, DateTime()));
CHECK_EQUAL(not_found, degen_child->find_first_string(5, StringData("")));
// CHECK_EQUAL(not_found, degen_child->find_first_binary(6, BinaryData())); // Exists but not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->find_all_int(0, 0).size());
CHECK_EQUAL(0, degen_child->find_all_bool(1, false).size());
CHECK_EQUAL(0, degen_child->find_all_float(2, 0).size());
CHECK_EQUAL(0, degen_child->find_all_double(3, 0).size());
CHECK_EQUAL(0, degen_child->find_all_datetime(4, DateTime()).size());
CHECK_EQUAL(0, degen_child->find_all_string(5, StringData("")).size());
// CHECK_EQUAL(0, degen_child->find_all_binary(6, BinaryData()).size()); // Exists but not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_subtable(7, subtab).size()); // Not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_mixed(8, Mixed()).size()); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->lower_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->lower_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->lower_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->lower_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->lower_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->upper_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->upper_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->upper_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->upper_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->upper_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_mixed(8, Mixed())); // Not yet implemented
// Aggregates:
CHECK_EQUAL(0, degen_child->count_int(0, 0));
// CHECK_EQUAL(0, degen_child->count_bool(1, false)); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_float(2, 0));
CHECK_EQUAL(0, degen_child->count_double(3, 0));
// CHECK_EQUAL(0, degen_child->count_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->count_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->minimum_int(0));
CHECK_EQUAL(0, degen_child->minimum_float(2));
CHECK_EQUAL(0, degen_child->minimum_double(3));
CHECK_EQUAL(0, degen_child->minimum_datetime(4));
CHECK_EQUAL(0, degen_child->maximum_int(0));
CHECK_EQUAL(0, degen_child->maximum_float(2));
CHECK_EQUAL(0, degen_child->maximum_double(3));
CHECK_EQUAL(0, degen_child->maximum_datetime(4));
CHECK_EQUAL(0, degen_child->sum_int(0));
CHECK_EQUAL(0, degen_child->sum_float(2));
CHECK_EQUAL(0, degen_child->sum_double(3));
CHECK_EQUAL(0, degen_child->average_int(0));
CHECK_EQUAL(0, degen_child->average_float(2));
CHECK_EQUAL(0, degen_child->average_double(3));
// Queries:
CHECK_EQUAL(not_found, degen_child->where().equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(1, false).find());
CHECK_EQUAL(not_found, degen_child->where().equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().equal_datetime(4, DateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().equal(8, Mixed()).find()); // Not yet implemented
CHECK_EQUAL(not_found, degen_child->where().not_equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal_datetime(4, DateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().not_equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().not_equal(8, Mixed()).find()); // Not yet implemented
TableView v = degen_child->where().equal(0, int64_t()).find_all();
CHECK_EQUAL(0, v.size());
v = degen_child->where().equal(5, "hello").find_all();
CHECK_EQUAL(0, v.size());
size_t r = degen_child->where().equal(5, "hello").count();
CHECK_EQUAL(0, r);
r = degen_child->where().equal(5, "hello").remove();
CHECK_EQUAL(0, r);
size_t res;
degen_child->where().equal(5, "hello").average_int(0, &res);
CHECK_EQUAL(0, res);
}
TEST(Table_Range)
{
Table table;
table.add_column(type_Int, "int");
table.add_empty_row(100);
for (size_t i = 0 ; i < 100; ++i)
table.set_int(0, i, i);
TableView tv = table.get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i < tv.size(); ++i)
CHECK_EQUAL(int64_t(i+10), tv.get_int(0, i));
}
TEST(Table_RangeConst)
{
Group group;
{
TableRef table = group.add_table("test");
table->add_column(type_Int, "int");
table->add_empty_row(100);
for (int i = 0 ; i < 100; ++i)
table->set_int(0, i, i);
}
ConstTableRef ctable = group.get_table("test");
ConstTableView tv = ctable->get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i<tv.size(); ++i)
CHECK_EQUAL(int64_t(i+10), tv.get_int(0, i));
}
// enable to generate testfiles for to_string below
#define GENERATE 0
TEST(Table_ToString)
{
Table table;
setup_multi_table(table, 15, 6);
std::stringstream ss;
table.to_string(ss);
const std::string result = ss.str();
std::string file_name = get_test_resource_path();
file_name += "expect_string.txt";
#if GENERATE // enable to generate testfile - check it manually
std::ofstream test_file(file_name.c_str(), std::ios::out);
test_file << result;
std::cerr << "to_string() test:\n" << result << std::endl;
#else
std::ifstream test_file(file_name.c_str(), std::ios::in);
CHECK(!test_file.fail());
std::string expected;
expected.assign( std::istreambuf_iterator<char>(test_file),
std::istreambuf_iterator<char>() );
bool test_ok = test_util::equal_without_cr(result, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
TEST_PATH(path);
File out(path, File::mode_Write);
out.write(result);
std::cerr << "\n error result in '" << std::string(path) << "'\n";
}
#endif
}
/* DISABLED BECAUSE IT FAILS - A PULL REQUEST WILL BE MADE WHERE IT IS REENABLED!
TEST(Table_RowToString)
{
// Create table with all column types
Table table;
setup_multi_table(table, 2, 2);
std::stringstream ss;
table.row_to_string(1, ss);
const std::string row_str = ss.str();
#if 0
std::ofstream test_file("row_to_string.txt", ios::out);
test_file << row_str;
#endif
std::string expected = " int bool date float double string string_long string_enum binary mixed tables\n"
"1: -1 true 1970-01-01 03:25:45 -1.234560e+002 -9.876543e+003 string1 string1 very long st... enum2 7 bytes -1 [3]\n";
bool test_ok = test_util::equal_without_cr(row_str, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
std::cerr << "row_to_string() failed\n"
<< "Expected: " << expected << "\n"
<< "Got : " << row_str << std::endl;
}
}
TEST(Table_FindInt)
{
TestTable table;
for (int i = 1000; i >= 0; --i) {
table.add(0, i, true, Wed);
}
CHECK_EQUAL(size_t(0), table.column().second.find_first(1000));
CHECK_EQUAL(size_t(1000), table.column().second.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(1001));
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
/*
TEST(Table_6)
{
TestTableEnum table;
RLM_QUERY(TestQuery, TestTableEnum) {
// first.between(Mon, Thu);
second == "Hello" || (second == "Hey" && first == Mon);
}};
RLM_QUERY_OPT(TestQuery2, TestTableEnum) (Days a, Days b, const char* str) {
(void)b;
(void)a;
//first.between(a, b);
second == str || second.MatchRegEx(".*");
}};
//TestTableEnum result = table.find_all(TestQuery2(Mon, Tue, "Hello")).sort().Limit(10);
//size_t result2 = table.Range(10, 200).find_first(TestQuery());
//CHECK_EQUAL((size_t)-1, result2);
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
TEST(Table_FindAllInt)
{
TestTable table;
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
// Search for a value that does not exits
const TestTable::View v0 = table.column().second.find_all(5);
CHECK_EQUAL(0, v0.size());
// Search for a value with several matches
const TestTable::View v = table.column().second.find_all(20);
CHECK_EQUAL(5, v.size());
CHECK_EQUAL(1, v.get_source_ndx(0));
CHECK_EQUAL(3, v.get_source_ndx(1));
CHECK_EQUAL(5, v.get_source_ndx(2));
CHECK_EQUAL(7, v.get_source_ndx(3));
CHECK_EQUAL(9, v.get_source_ndx(4));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_SortedInt)
{
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, true, Wed); // 1: 7
table.add(0, 0, true, Wed); // 2: 0
table.add(0, 40, true, Wed); // 3: 8
table.add(0, 15, true, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Search for a value that does not exits
TestTable::View v = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v.size());
CHECK_EQUAL(2, v.get_source_ndx(0));
CHECK_EQUAL(9, v.get_source_ndx(1));
CHECK_EQUAL(7, v.get_source_ndx(2));
CHECK_EQUAL(6, v.get_source_ndx(3));
CHECK_EQUAL(0, v.get_source_ndx(4));
CHECK_EQUAL(5, v.get_source_ndx(5));
CHECK_EQUAL(4, v.get_source_ndx(6));
CHECK_EQUAL(1, v.get_source_ndx(7));
CHECK_EQUAL(3, v.get_source_ndx(8));
CHECK_EQUAL(8, v.get_source_ndx(9));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Sorted_Query_where)
{
// Using where(tv) instead of tableview(tv)
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, false, Wed); // 1: 7
table.add(0, 0, false, Wed); // 2: 0
table.add(0, 40, false, Wed); // 3: 8
table.add(0, 15, false, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Count booleans
size_t count_original = table.where().third.equal(false).count();
CHECK_EQUAL(4, count_original);
// Get a view containing the complete table
TestTable::View v = table.column().first.find_all(0);
CHECK_EQUAL(table.size(), v.size());
// Count booleans
size_t count_view = table.where(&v).third.equal(false).count();
CHECK_EQUAL(4, count_view);
TestTable::View v_sorted = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v_sorted.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Multi_Sort)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
table.add_empty_row(5);
// 1, 10
table.set_int(0, 0, 1);
table.set_int(1, 0, 10);
// 2, 10
table.set_int(0, 1, 2);
table.set_int(1, 1, 10);
// 0, 10
table.set_int(0, 2, 0);
table.set_int(1, 2, 10);
// 2, 14
table.set_int(0, 3, 2);
table.set_int(1, 3, 14);
// 1, 14
table.set_int(0, 4, 1);
table.set_int(1, 4, 14);
std::vector<size_t> col_ndx1;
col_ndx1.push_back(0);
col_ndx1.push_back(1);
std::vector<bool> asc;
asc.push_back(true);
asc.push_back(true);
// (0, 10); (1, 10); (1, 14); (2, 10); (2; 14)
TableView v_sorted1 = table.get_sorted_view(col_ndx1, asc);
CHECK_EQUAL(table.size(), v_sorted1.size());
CHECK_EQUAL(2, v_sorted1.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted1.get_source_ndx(1));
CHECK_EQUAL(4, v_sorted1.get_source_ndx(2));
CHECK_EQUAL(1, v_sorted1.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted1.get_source_ndx(4));
std::vector<size_t> col_ndx2;
col_ndx2.push_back(1);
col_ndx2.push_back(0);
// (0, 10); (1, 10); (2, 10); (1, 14); (2, 14)
TableView v_sorted2 = table.get_sorted_view(col_ndx2, asc);
CHECK_EQUAL(table.size(), v_sorted2.size());
CHECK_EQUAL(2, v_sorted2.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted2.get_source_ndx(1));
CHECK_EQUAL(1, v_sorted2.get_source_ndx(2));
CHECK_EQUAL(4, v_sorted2.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted2.get_source_ndx(4));
}
TEST(Table_IndexString)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); //duplicate
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
const size_t r1 = table.column().second.find_first("jimmi");
CHECK_EQUAL(not_found, r1);
const size_t r2 = table.column().second.find_first("jeff");
const size_t r3 = table.column().second.find_first("jim");
const size_t r4 = table.column().second.find_first("jimbo");
const size_t r5 = table.column().second.find_first("johnny");
CHECK_EQUAL(0, r2);
CHECK_EQUAL(1, r3);
CHECK_EQUAL(5, r4);
CHECK_EQUAL(6, r5);
const size_t c1 = table.column().second.count("jennifer");
CHECK_EQUAL(2, c1);
}
TEST(Table_IndexStringTwice)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); // duplicate
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
}
// Tests Table part of index on Int, DateTime and Bool columns. For a more exhaustive
// test of the integer index (bypassing Table), see test_index_string.cpp)
TEST(Table_IndexInteger)
{
Table table;
size_t r;
table.add_column(type_Int, "ints");
table.add_column(type_DateTime, "date");
table.add_column(type_Bool, "date");
table.add_empty_row(13);
table.set_int(0, 0, 3); // 0
table.set_int(0, 1, 1); // 1
table.set_int(0, 2, 2); // 2
table.set_int(0, 3, 2); // 3
table.set_int(0, 4, 2); // 4
table.set_int(0, 5, 3); // 5
table.set_int(0, 6, 3); // 6
table.set_int(0, 7, 2); // 7
table.set_int(0, 8, 4); // 8
table.set_int(0, 9, 2); // 9
table.set_int(0, 10, 6); // 10
table.set_int(0, 11, 2); // 11
table.set_int(0, 12, 3); // 12
table.add_search_index(0);
CHECK(table.has_search_index(0));
table.add_search_index(1);
CHECK(table.has_search_index(1));
table.add_search_index(2);
CHECK(table.has_search_index(2));
table.set_datetime(1, 10, DateTime(43));
r = table.find_first_datetime(1, DateTime(43));
CHECK_EQUAL(10, r);
table.set_bool(2, 11, true);
r = table.find_first_bool(2, true);
CHECK_EQUAL(11, r);
r = table.find_first_int(0, 11);
CHECK_EQUAL(not_found, r);
r = table.find_first_int(0, 3);
CHECK_EQUAL(0, r);
r = table.find_first_int(0, 4);
CHECK_EQUAL(8, r);
TableView tv = table.find_all_int(0, 2);
CHECK_EQUAL(6, tv.size());
CHECK_EQUAL(2, tv[0].get_index());
CHECK_EQUAL(3, tv[1].get_index());
CHECK_EQUAL(4, tv[2].get_index());
CHECK_EQUAL(7, tv[3].get_index());
CHECK_EQUAL(9, tv[4].get_index());
CHECK_EQUAL(11, tv[5].get_index());
}
TEST(Table_PrimaryKeyBasics)
{
// Note: Formally, member functions of Table are not required to leave the
// table in a valid state when they throw LogicError. In the cases below,
// however, informed by the actual implementation of these functions, we
// assume that they do allow us to continue, but please remember that this
// is not generally the case.
Table table;
table.add_column(type_String, "");
// Empty table
CHECK_NOT(table.has_primary_key());
CHECK_LOGIC_ERROR(table.find_pkey_string("foo"), LogicError::no_primary_key);
CHECK_LOGIC_ERROR(table.try_add_primary_key(0), LogicError::no_search_index);
table.add_search_index(0);
CHECK_NOT(table.has_primary_key());
CHECK_LOGIC_ERROR(table.find_pkey_string("foo"), LogicError::no_primary_key);
CHECK(table.try_add_primary_key(0));
CHECK(table.has_primary_key());
CHECK_NOT(table.find_pkey_string("foo"));
// One row
table.remove_primary_key();
table.add_empty_row();
table.set_string(0, 0, "foo");
CHECK_LOGIC_ERROR(table.find_pkey_string("foo"), LogicError::no_primary_key);
CHECK(table.try_add_primary_key(0));
CHECK_EQUAL(0, table.find_pkey_string("foo").get_index());
CHECK_NOT(table.find_pkey_string("bar"));
// Two rows
table.remove_primary_key();
table.add_empty_row();
table.set_string(0, 1, "bar");
CHECK(table.try_add_primary_key(0));
CHECK_EQUAL(0, table.find_pkey_string("foo").get_index());
CHECK_EQUAL(1, table.find_pkey_string("bar").get_index());
// Modify primary key
CHECK_LOGIC_ERROR(table.set_string(0, 1, "foo"), LogicError::unique_constraint_violation);
table.set_string(0, 1, "bar");
table.set_string(0, 1, "baz");
CHECK_EQUAL(0, table.find_pkey_string("foo").get_index());
CHECK_NOT(table.find_pkey_string("bar"));
CHECK_EQUAL(1, table.find_pkey_string("baz").get_index());
// Insert row
// Unfortunately, we could not have recovered and continued if we had let
// Table::insert_string() throw.
// CHECK_LOGIC_ERROR(table.insert_string(0, 2, "foo"), LogicError::unique_constraint_violation);
table.verify();
table.insert_empty_row(2);
table.set_string(0, 2, "bar");
table.verify();
table.add_empty_row();
table.verify();
// Unfortunately, we could not have recovered and continued if we had let
// Table::add_empty_row() throw.
// CHECK_LOGIC_ERROR(table.add_empty_row(), LogicError::unique_constraint_violation);
// Duplicate key value
table.remove_primary_key();
table.set_string(0, 1, "foo");
CHECK_NOT(table.try_add_primary_key(0));
}
TEST(Table_PrimaryKeyLargeCommonPrefix)
{
Table table;
table.add_column(type_String, "");
table.add_empty_row(2);
table.set_string(0, 0, "metasyntactic variable 1");
table.set_string(0, 1, "metasyntactic variable 2");
table.add_search_index(0);
CHECK(table.try_add_primary_key(0));
CHECK_LOGIC_ERROR(table.set_string(0, 1, "metasyntactic variable 1"),
LogicError::unique_constraint_violation);
table.set_string(0, 1, "metasyntactic variable 2");
table.set_string(0, 1, "metasyntactic variable 3");
}
TEST(Table_PrimaryKeyExtra)
{
Table table;
table.add_column(type_String, "");
table.add_column(type_Int, "");
table.add_empty_row(8);
table.set_string(0, 0, "jeff");
table.set_string(0, 1, "jim");
table.set_string(0, 2, "jennifer");
table.set_string(0, 3, "john");
table.set_string(0, 4, "jimmy");
table.set_string(0, 5, "jimbo");
table.set_string(0, 6, "johnny");
table.set_string(0, 7, "jennifer"); // Duplicate primary key
table.set_int(1, 0, 0);
table.set_int(1, 1, 1);
table.set_int(1, 2, 2);
table.set_int(1, 3, 3);
table.set_int(1, 4, 4);
table.set_int(1, 5, 5);
table.set_int(1, 6, 6);
table.set_int(1, 7, 7);
CHECK_LOGIC_ERROR(table.find_pkey_string("jeff"), LogicError::no_primary_key);
CHECK_LOGIC_ERROR(table.try_add_primary_key(0), LogicError::no_search_index);
CHECK_NOT(table.has_primary_key());
table.add_search_index(0);
CHECK(table.has_search_index(0));
CHECK_NOT(table.try_add_primary_key(0));
CHECK_NOT(table.has_primary_key());
table.set_string(0, 7, "jennifer 8");
CHECK(table.try_add_primary_key(0));
CHECK(table.has_primary_key());
table.verify();
Row a0 = table.find_pkey_string("jeff");
Row a1 = table.find_pkey_string("jim");
Row a2 = table.find_pkey_string("jennifer");
Row a3 = table.find_pkey_string("john");
Row a4 = table.find_pkey_string("jimmy");
Row a5 = table.find_pkey_string("jimbo");
Row a6 = table.find_pkey_string("johnny");
Row a7 = table.find_pkey_string("jerry");
CHECK(a0);
CHECK(a1);
CHECK(a2);
CHECK(a3);
CHECK(a4);
CHECK(a5);
CHECK(a6);
CHECK_NOT(a7);
CHECK_EQUAL(0, a0.get_index());
CHECK_EQUAL(1, a1.get_index());
CHECK_EQUAL(2, a2.get_index());
CHECK_EQUAL(3, a3.get_index());
CHECK_EQUAL(4, a4.get_index());
CHECK_EQUAL(5, a5.get_index());
CHECK_EQUAL(6, a6.get_index());
}
TEST(Table_SubtablePrimaryKey)
{
Table parent;
parent.add_column(type_Table, "");
parent.get_subdescriptor(0)->add_column(type_String, "");
parent.add_empty_row();
TableRef child = parent[0].get_subtable(0);
CHECK_LOGIC_ERROR(child->find_pkey_string("foo"), LogicError::no_primary_key);
CHECK_LOGIC_ERROR(child->add_search_index(0), LogicError::wrong_kind_of_table);
}
TEST(Table_Distinct)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
TestTableEnum::View view = table.column().second.get_distinct_view();
CHECK_EQUAL(4, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(5, view.get_source_ndx(3));
}
TEST(Table_DistinctEnums)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().first.add_search_index();
CHECK(table.column().first.has_search_index());
TestTableEnum::View view = table.column().first.get_distinct_view();
CHECK_EQUAL(7, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(3, view.get_source_ndx(3));
CHECK_EQUAL(4, view.get_source_ndx(4));
CHECK_EQUAL(5, view.get_source_ndx(5));
CHECK_EQUAL(6, view.get_source_ndx(6));
}
TEST(Table_DistinctIntegers)
{
Table table;
table.add_column(type_Int, "first");
table.add_empty_row(4);
table.set_int(0, 0, 1);
table.set_int(0, 1, 2);
table.set_int(0, 2, 3);
table.set_int(0, 3, 3);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
TEST(Table_DistinctBool)
{
Table table;
table.add_column(type_Bool, "first");
table.add_empty_row(4);
table.set_bool(0, 0, true);
table.set_bool(0, 1, false);
table.set_bool(0, 2, true);
table.set_bool(0, 3, false);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(2, view.size());
CHECK_EQUAL(0, view.get_source_ndx(1));
CHECK_EQUAL(1, view.get_source_ndx(0));
}
/*
// FIXME Commented out because indexes on floats and doubles are not supported (yet).
TEST(Table_DistinctFloat)
{
Table table;
table.add_column(type_Float, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_float(0, i, static_cast<float>(i) + 0.5f);
}
table.set_float(0, 10, 0.5f);
table.set_float(0, 11, 1.5f);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
TEST(Table_DistinctDouble)
{
Table table;
table.add_column(type_Double, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_double(0, i, static_cast<double>(i) + 0.5);
}
table.set_double(0, 10, 0.5);
table.set_double(0, 11, 1.5);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
*/
TEST(Table_DistinctDateTime)
{
Table table;
table.add_column(type_DateTime, "first");
table.add_empty_row(4);
table.set_datetime(0, 0, DateTime(0));
table.set_datetime(0, 1, DateTime(1));
table.set_datetime(0, 2, DateTime(3));
table.set_datetime(0, 3, DateTime(3));
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
}
TEST(Table_DistinctFromPersistedTable)
{
GROUP_TEST_PATH(path);
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "first");
table->add_empty_row(4);
table->set_int(0, 0, 1);
table->set_int(0, 1, 2);
table->set_int(0, 2, 3);
table->set_int(0, 3, 3);
table->add_search_index(0);
CHECK(table->has_search_index(0));
group.write(path);
}
{
Group group(path, 0, Group::mode_ReadOnly);
TableRef table = group.get_table("table");
TableView view = table->get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
}
TEST(Table_IndexInt)
{
TestTable table;
table.add(0, 1, true, Wed);
table.add(0, 15, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 11, true, Wed);
table.add(0, 45, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 0, true, Wed);
table.add(0, 30, true, Wed);
table.add(0, 9, true, Wed);
// Create index for column two
table.column().second.add_search_index();
// Search for a value that does not exits
const size_t r1 = table.column().second.find_first(2);
CHECK_EQUAL(npos, r1);
// Find existing values
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(10));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
//CHECK_EQUAL(6, table.column().second.find_first(10)); // only finds first match
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(9));
// Change some values
table[2].second = 13;
table[9].second = 100;
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
// Insert values
table.add(0, 29, true, Wed);
//TODO: More than add
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
CHECK_EQUAL(10, table.column().second.find_first(29));
// Delete some values
table.remove(0);
table.remove(5);
table.remove(8);
CHECK_EQUAL(0, table.column().second.find_first(15));
CHECK_EQUAL(1, table.column().second.find_first(13));
CHECK_EQUAL(2, table.column().second.find_first(20));
CHECK_EQUAL(3, table.column().second.find_first(11));
CHECK_EQUAL(4, table.column().second.find_first(45));
CHECK_EQUAL(5, table.column().second.find_first(0));
CHECK_EQUAL(6, table.column().second.find_first(30));
CHECK_EQUAL(7, table.column().second.find_first(100));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_4(TestTableAE,
first, Int,
second, String,
third, Bool,
fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_AutoEnumeration)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
for (size_t i = 0; i < 5; ++i) {
const size_t n = i * 5;
CHECK_EQUAL(1, table[0+n].first);
CHECK_EQUAL(2, table[1+n].first);
CHECK_EQUAL(5, table[2+n].first);
CHECK_EQUAL(8, table[3+n].first);
CHECK_EQUAL(9, table[4+n].first);
CHECK_EQUAL("abd", table[0+n].second);
CHECK_EQUAL("eftg", table[1+n].second);
CHECK_EQUAL("hijkl", table[2+n].second);
CHECK_EQUAL("mnopqr", table[3+n].second);
CHECK_EQUAL("stuvxyz", table[4+n].second);
CHECK_EQUAL(true, table[0+n].third);
CHECK_EQUAL(true, table[1+n].third);
CHECK_EQUAL(true, table[2+n].third);
CHECK_EQUAL(true, table[3+n].third);
CHECK_EQUAL(true, table[4+n].third);
CHECK_EQUAL(Mon, table[0+n].fourth);
CHECK_EQUAL(Tue, table[1+n].fourth);
CHECK_EQUAL(Wed, table[2+n].fourth);
CHECK_EQUAL(Thu, table[3+n].fourth);
CHECK_EQUAL(Fri, table[4+n].fourth);
}
// Verify counts
const size_t count1 = table.column().second.count("abd");
const size_t count2 = table.column().second.count("eftg");
const size_t count3 = table.column().second.count("hijkl");
const size_t count4 = table.column().second.count("mnopqr");
const size_t count5 = table.column().second.count("stuvxyz");
CHECK_EQUAL(5, count1);
CHECK_EQUAL(5, count2);
CHECK_EQUAL(5, count3);
CHECK_EQUAL(5, count4);
CHECK_EQUAL(5, count5);
}
TEST(Table_AutoEnumerationFindFindAll)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
size_t t = table.column().second.find_first("eftg");
CHECK_EQUAL(1, t);
TestTableAE::View tv = table.column().second.find_all("eftg");
CHECK_EQUAL(5, tv.size());
CHECK_EQUAL("eftg", tv[0].second);
CHECK_EQUAL("eftg", tv[1].second);
CHECK_EQUAL("eftg", tv[2].second);
CHECK_EQUAL("eftg", tv[3].second);
CHECK_EQUAL("eftg", tv[4].second);
}
namespace {
REALM_TABLE_4(TestTableEnum4,
col1, String,
col2, String,
col3, String,
col4, String)
} // anonymous namespace
TEST(Table_AutoEnumerationOptimize)
{
TestTableEnum4 t;
// Insert non-optimzable strings
std::string s;
for (size_t i = 0; i < 10; ++i) {
t.add(s.c_str(), s.c_str(), s.c_str(), s.c_str());
s += "x";
}
t.optimize();
// AutoEnumerate in reverse order
for (size_t i = 0; i < 10; ++i) {
t[i].col4 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col3 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col2 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col1 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
CHECK_EQUAL("test", t[i].col1);
CHECK_EQUAL("test", t[i].col2);
CHECK_EQUAL("test", t[i].col3);
CHECK_EQUAL("test", t[i].col4);
}
#ifdef REALM_DEBUG
t.verify();
#endif
}
namespace {
REALM_TABLE_1(TestSubtabEnum2,
str, String)
REALM_TABLE_1(TestSubtabEnum1,
subtab, Subtable<TestSubtabEnum2>)
} // anonymous namespace
TEST(Table_OptimizeSubtable)
{
TestSubtabEnum1 t;
t.add();
t.add();
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (int i=0; i<100; ++i) {
r->add(s.c_str());
s += 'x';
}
}
{
// Enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (int i=0; i<100; ++i) {
r->add("foo");
}
r->optimize();
}
// Verify
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL(s.c_str(), r[i].str);
s += 'x';
}
}
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL("foo", r[i].str);
}
}
}
TEST(Table_OptimizeCompare)
{
TestSubtabEnum2 t1, t2;
for (int i=0; i<100; ++i) {
t1.add("foo");
}
for (int i=0; i<100; ++i) {
t2.add("foo");
}
t1.optimize();
CHECK(t1 == t2);
t1[50].str = "bar";
CHECK(t1 != t2);
t1[50].str = "foo";
CHECK(t1 == t2);
t2[50].str = "bar";
CHECK(t1 != t2);
t2[50].str = "foo";
CHECK(t1 == t2);
}
TEST(Table_SlabAlloc)
{
SlabAlloc alloc;
alloc.attach_empty();
TestTable table(alloc);
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL( 0, r.first);
CHECK_EQUAL( 10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL( Wed, r.fourth);
// Add some more rows
table.add(1, 10, true, Wed);
table.add(2, 20, true, Wed);
table.add(3, 10, true, Wed);
table.add(4, 20, true, Wed);
table.add(5, 10, true, Wed);
// Delete some rows
table.remove(2);
table.remove(4);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Spec)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
{
DescriptorRef sub_1;
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third", &sub_1);
sub_1->add_column(type_Int, "sub_first");
sub_1->add_column(type_String, "sub_second");
}
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Write the group to disk
GROUP_TEST_PATH(path);
group.write(path);
// Read back tables
{
Group from_disk(path, 0, Group::mode_ReadOnly);
TableRef from_disk_table = from_disk.get_table("test");
TableRef subtable2 = from_disk_table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("test", subtable2->get_string(1, 0));
}
}
TEST(Table_SpecColumnPath)
{
Group group;
TableRef table = group.add_table("test");
// Create path to sub-table column (starting with root)
std::vector<size_t> column_path;
// Create specification with sub-table
table->add_subcolumn(column_path, type_Int, "first");
table->add_subcolumn(column_path, type_String, "second");
table->add_subcolumn(column_path, type_Table, "third");
column_path.push_back(2); // third column (which is a sub-table col)
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
}
TEST(Table_SpecRenameColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Rename first column
table->rename_column(0, "1st");
CHECK_EQUAL(0, table->get_column_index("1st"));
// Rename sub-column
table->rename_subcolumn(column_path, 0, "sub_1st"); // third
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(0, subtable->get_column_index("sub_1st"));
}
}
TEST(Table_SpecDeleteColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
table->add_column(type_String, "fourth"); // will be auto-enumerated
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(4, table->get_column_count());
// Add a few rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->set_string(3, 0, "X");
table->insert_empty_row(1);
table->set_int(0, 1, 4);
table->set_string(1, 1, "World");
table->set_string(3, 1, "X");
table->insert_empty_row(2);
table->set_int(0, 2, 4);
table->set_string(1, 2, "Goodbye");
table->set_string(3, 2, "X");
// We want the last column to be StringEnum column
table->optimize();
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Remove the first column
table->remove_column(0);
CHECK_EQUAL(3, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(2, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Create path to column in sub-table
column_path.clear();
column_path.push_back(1); // third
// Remove a column in sub-table
table->remove_subcolumn(column_path, 1); // sub_second
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(1, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
}
// Remove sub-table column (with all members)
table->remove_column(1);
CHECK_EQUAL(2, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(1, 0));
// Remove optimized string column
table->remove_column(1);
CHECK_EQUAL(1, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
// Remove last column
table->remove_column(0);
CHECK_EQUAL(0, table->get_column_count());
CHECK(table->is_empty());
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_NullInEnum)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "second", true);
for (size_t c = 0; c < 100; c++) {
table->insert_empty_row(c);
table->set_string(0, c, "hello");
}
size_t r;
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->optimize();
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->set_string(0, 50, "hello");
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
table->set_string(0, 55, realm::null());
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(2, r);
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(98, r);
table->remove(55);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
}
TEST(Table_SpecAddColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Add a new bool column
table->add_column(type_Bool, "fourth");
CHECK_EQUAL(4, table->get_column_count());
CHECK_EQUAL(false, table->get_bool(3, 0));
// Add a new string column
table->add_column(type_String, "fifth");
CHECK_EQUAL(5, table->get_column_count());
CHECK_EQUAL("", table->get_string(4, 0));
// Add a new table column
table->add_column(type_Table, "sixth");
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(0, table->get_subtable_size(5, 0));
// Add a new mixed column
table->add_column(type_Mixed, "seventh");
CHECK_EQUAL(7, table->get_column_count());
CHECK_EQUAL(0, table->get_mixed(6, 0).get_int());
// Create path to column in sub-table
column_path.clear();
column_path.push_back(2); // third
// Add new int column to sub-table
table->add_subcolumn(column_path, type_Int, "sub_third");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(3, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
}
// Add new table column to sub-table
table->add_subcolumn(column_path, type_Table, "sub_fourth");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
CHECK_EQUAL(0, subtable->get_subtable_size(3, 0));
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
}
// Add new column to new sub-table
column_path.push_back(3); // sub_forth
table->add_subcolumn(column_path, type_String, "first");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
TableRef subsubtable = subtable->get_subtable(3, 0);
CHECK_EQUAL(1, subsubtable->get_column_count());
}
// Add a new mixed column
table->add_column(type_Mixed, "eighth");
CHECK_EQUAL(8, table->get_column_count());
table->set_mixed(7, 0, Mixed::subtable_tag());
TableRef stab = table->get_subtable(7, 0);
stab->add_column(type_Int, "smurf");
stab->insert_empty_row(0);
stab->set_int(0, 0, 1);
stab->insert_empty_row(1);
stab->set_int(0, 1, 2);
CHECK_EQUAL(2, table->get_subtable_size(7, 0));
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_SpecDeleteColumnsBug)
{
TableRef table = Table::create();
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_search_index(0);
table->add_column(type_Int, "age");
table->add_column(type_Bool, "hired");
table->add_column(type_Table, "phones");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(3); // phones
table->add_subcolumn(column_path, type_String, "type");
table->add_subcolumn(column_path, type_String, "number");
// Add rows
table->add_empty_row();
table->set_string(0, 0, "jessica");
table->set_int(1, 0, 22);
table->set_bool(2, 0, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "232-323-3242");
}
table->add_empty_row();
table->set_string(0, 1, "joe");
table->set_int(1, 1, 42);
table->set_bool(2, 1, false);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "work");
phones->set_string(1, 0, "434-434-4343");
}
table->add_empty_row();
table->set_string(0, 1, "jared");
table->set_int(1, 1, 35);
table->set_bool(2, 1, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "342-323-3242");
phones->add_empty_row();
phones->set_string(0, 0, "school");
phones->set_string(1, 0, "434-432-5433");
}
// Add new column
table->add_column(type_Mixed, "extra");
table->set_mixed(4, 0, true);
table->set_mixed(4, 2, "Random string!");
// Remove some columns
table->remove_column(1); // age
table->remove_column(3); // extra
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_Mixed)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Mixed, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Mixed, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
const size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_mixed(1, ndx, true);
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
table.insert_empty_row(1);
table.set_int(0, 1, 43);
table.set_mixed(1, 1, (int64_t)12);
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
table.insert_empty_row(2);
table.set_int(0, 2, 100);
table.set_mixed(1, 2, "test");
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
table.insert_empty_row(3);
table.set_int(0, 3, 0);
table.set_mixed(1, 3, DateTime(324234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime,table.get_mixed(1, 3).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
table.insert_empty_row(4);
table.set_int(0, 4, 43);
table.set_mixed(1, 4, Mixed(BinaryData("binary", 7)));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
table.insert_empty_row(5);
table.set_int(0, 5, 0);
table.set_mixed(1, 5, Mixed::subtable_tag());
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
// Get table from mixed column and add schema and some values
TableRef subtable = table.get_subtable(1, 5);
subtable->add_column(type_String, "name");
subtable->add_column(type_Int, "age");
subtable->insert_empty_row(0);
subtable->set_string(0, 0, "John");
subtable->set_int(1, 0, 40);
// Get same table again and verify values
TableRef subtable2 = table.get_subtable(1, 5);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL("John", subtable2->get_string(0, 0));
CHECK_EQUAL(40, subtable2->get_int(1, 0));
// Insert float, double
table.insert_empty_row(6);
table.set_int(0, 6, 31);
table.set_mixed(1, 6, float(1.123));
table.insert_empty_row(7);
table.set_int(0, 7, 0);
table.set_mixed(1, 7, double(2.234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(31, table.get_int(0, 6));
CHECK_EQUAL(0, table.get_int(0, 7));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_DateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(type_Float, table.get_mixed(1, 6).get_type());
CHECK_EQUAL(type_Double, table.get_mixed(1, 7).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_datetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
CHECK_EQUAL(float(1.123), table.get_mixed(1, 6).get_float());
CHECK_EQUAL(double(2.234), table.get_mixed(1, 7).get_double());
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_1(TestTableMX,
first, Mixed)
} // anonymous namespace
TEST(Table_Mixed2)
{
TestTableMX table;
table.add(int64_t(1));
table.add(true);
table.add(DateTime(1234));
table.add("test");
CHECK_EQUAL(type_Int, table[0].first.get_type());
CHECK_EQUAL(type_Bool, table[1].first.get_type());
CHECK_EQUAL(type_DateTime, table[2].first.get_type());
CHECK_EQUAL(type_String, table[3].first.get_type());
CHECK_EQUAL(1, table[0].first.get_int());
CHECK_EQUAL(true, table[1].first.get_bool());
CHECK_EQUAL(1234, table[2].first.get_datetime());
CHECK_EQUAL("test", table[3].first.get_string());
}
TEST(Table_SubtableSizeAndClear)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "subtab", &subdesc);
table.add_column(type_Mixed, "mixed");
subdesc->add_column(type_Int, "int");
table.insert_empty_row(0);
table.insert_empty_row(1);
Table subtable;
table.set_mixed_subtable(1, 1, &subtable);
CHECK_EQUAL(0, table.get_subtable_size(0,0)); // Subtable column
CHECK_EQUAL(0, table.get_subtable_size(1,0)); // Mixed column, bool value
CHECK_EQUAL(0, table.get_subtable_size(1,1)); // Mixed column, table value
CHECK(table.get_subtable(0,0)); // Subtable column
CHECK(!table.get_subtable(1,0)); // Mixed column, bool value, must return nullptr
CHECK(table.get_subtable(1,1)); // Mixed column, table value
table.set_mixed(1, 0, Mixed::subtable_tag());
table.set_mixed(1, 1, false);
CHECK(table.get_subtable(1,0));
CHECK(!table.get_subtable(1,1));
TableRef subtab1 = table.get_subtable(0,0);
TableRef subtab2 = table.get_subtable(1,0);
subtab2->add_column(type_Int, "int");
CHECK_EQUAL(0, table.get_subtable_size(1,0));
CHECK(table.get_subtable(1,0));
subtab1->insert_empty_row(0);
subtab2->insert_empty_row(0);
CHECK_EQUAL(1, table.get_subtable_size(0,0));
CHECK_EQUAL(1, table.get_subtable_size(1,0));
table.clear_subtable(0,0);
table.clear_subtable(1,0);
CHECK_EQUAL(0, table.get_subtable_size(0,0));
CHECK_EQUAL(0, table.get_subtable_size(1,0));
CHECK(table.get_subtable(1,0));
}
TEST(Table_LowLevelSubtables)
{
Table table;
std::vector<size_t> column_path;
table.add_column(type_Table, "subtab");
table.add_column(type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
table.add_empty_row(2);
CHECK_EQUAL(2, table.size());
for (int i_1 = 0; i_1 != 2; ++i_1) {
TableRef subtab = table.get_subtable(0, i_1);
subtab->add_empty_row(2 + i_1);
CHECK_EQUAL(2 + i_1, subtab->size());
{
TableRef subsubtab = subtab->get_subtable(0, 0 + i_1);
subsubtab->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 3 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab->clear_subtable(1, 1 + i_1); // Mixed
TableRef subsubtab_mix = subtab->get_subtable(1, 1 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(1 + i_1);
CHECK_EQUAL(1 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 1 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 1 + i_1, bool(subtab->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 0 + i_1 ? 3 + i_1 : 0, subtab->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 1 + i_1 ? 1 + i_1 : 0, subtab->get_subtable_size(1, i_2)); // Mixed
}
table.clear_subtable(1, i_1); // Mixed
TableRef subtab_mix = table.get_subtable(1, i_1);
std::vector<size_t> subcol_path;
subtab_mix->add_column(type_Table, "subtab");
subtab_mix->add_column(type_Mixed, "mixed");
subcol_path.push_back(0);
subtab_mix->add_subcolumn(subcol_path, type_Table, "subtab");
subtab_mix->add_subcolumn(subcol_path, type_Mixed, "mixed");
subtab_mix->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subtab_mix->size());
{
TableRef subsubtab = subtab_mix->get_subtable(0, 1 + i_1);
subsubtab->add_empty_row(7 + i_1);
CHECK_EQUAL(7 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 7 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab_mix->clear_subtable(1, 2 + i_1); // Mixed
TableRef subsubtab_mix = subtab_mix->get_subtable(1, 2 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(5 + i_1);
CHECK_EQUAL(5 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 5 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab_mix->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 2 + i_1, bool(subtab_mix->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 1 + i_1 ? 7 + i_1 : 0, subtab_mix->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 2 + i_1 ? 5 + i_1 : 0, subtab_mix->get_subtable_size(1, i_2)); // Mixed
}
CHECK_EQUAL(true, bool(table.get_subtable(0, i_1)));
CHECK_EQUAL(true, bool(table.get_subtable(1, i_1))); // Mixed
CHECK_EQUAL(2 + i_1, table.get_subtable_size(0, i_1));
CHECK_EQUAL(3 + i_1, table.get_subtable_size(1, i_1)); // Mixed
}
}
namespace {
REALM_TABLE_2(MyTable1,
val, Int,
val2, Int)
REALM_TABLE_2(MyTable2,
val, Int,
subtab, Subtable<MyTable1>)
REALM_TABLE_1(MyTable3,
subtab, Subtable<MyTable2>)
REALM_TABLE_1(MyTable4,
mix, Mixed)
} // anonymous namespace
TEST(Table_HighLevelSubtables)
{
MyTable3 t;
{
MyTable3::Ref r1 = t.get_table_ref();
MyTable3::ConstRef r2 = t.get_table_ref();
MyTable3::ConstRef r3 = r2->get_table_ref();
r3 = t.get_table_ref(); // Also test assigment that converts to const
static_cast<void>(r1);
static_cast<void>(r3);
}
t.add();
const MyTable3& ct = t;
{
MyTable2::Ref s1 = t[0].subtab;
MyTable2::ConstRef s2 = t[0].subtab;
MyTable2::Ref s3 = t[0].subtab->get_table_ref();
MyTable2::ConstRef s4 = t[0].subtab->get_table_ref();
MyTable2::Ref s5 = t.column().subtab[0];
MyTable2::ConstRef s6 = t.column().subtab[0];
MyTable2::Ref s7 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef s8 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef cs1 = ct[0].subtab;
MyTable2::ConstRef cs2 = ct[0].subtab->get_table_ref();
MyTable2::ConstRef cs3 = ct.column().subtab[0];
MyTable2::ConstRef cs4 = ct.column().subtab[0]->get_table_ref();
s1 = t[0].subtab;
s2 = t[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab->add();
{
MyTable1::Ref s1 = t[0].subtab[0].subtab;
MyTable1::ConstRef s2 = t[0].subtab[0].subtab;
MyTable1::Ref s3 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef s4 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::Ref s5 = t.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef s6 = t.column().subtab[0]->column().subtab[0];
MyTable1::Ref s7 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef s8 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef cs1 = ct[0].subtab[0].subtab;
MyTable1::ConstRef cs2 = ct[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef cs3 = ct.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef cs4 = ct.column().subtab[0]->column().subtab[0]->get_table_ref();
s1 = t[0].subtab[0].subtab;
s2 = t[0].subtab[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab[0].val = 1;
CHECK_EQUAL(t[0].subtab[0].val, 1);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 1);
CHECK_EQUAL(t[0].subtab->column().val[0], 1);
CHECK_EQUAL(t.column().subtab[0][0].val, 1);
t.column().subtab[0]->column().val[0] = 2;
CHECK_EQUAL(t[0].subtab[0].val, 2);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 2);
CHECK_EQUAL(t[0].subtab->column().val[0], 2);
CHECK_EQUAL(t.column().subtab[0][0].val, 2);
t[0].subtab->column().val[0] = 3;
CHECK_EQUAL(t[0].subtab[0].val, 3);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 3);
CHECK_EQUAL(t[0].subtab->column().val[0], 3);
CHECK_EQUAL(t.column().subtab[0][0].val, 3);
t.column().subtab[0][0].val = 4;
CHECK_EQUAL(t[0].subtab[0].val, 4);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(t[0].subtab->column().val[0], 4);
CHECK_EQUAL(t.column().subtab[0][0].val, 4);
CHECK_EQUAL(ct[0].subtab[0].val, 4);
CHECK_EQUAL(ct.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(ct[0].subtab->column().val[0], 4);
CHECK_EQUAL(ct.column().subtab[0][0].val, 4);
t[0].subtab[0].subtab->add();
t[0].subtab[0].subtab[0].val = 5;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 5);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 5);
t.column().subtab[0]->column().subtab[0]->column().val[0] = 6;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 6);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 6);
/*
Idea for compile time failure tests:
const MyTable2 t;
#if TEST_INDEX == 0
t[0].val = 7;
#elsif TEST_INDEX == 1
t.column().val[0] = 7;
#elsif TEST_INDEX == 2
t[0].subtab[0].val = 7;
#elsif TEST_INDEX == 3
t[0].subtab->column().val[0] = 7;
#endif
*/
}
TEST(Table_SubtableCopyOnSetAndInsert)
{
MyTable1 t1;
t1.add(7, 8);
MyTable2 t2;
t2.add(9, &t1);
MyTable1::Ref r1 = t2[0].subtab;
CHECK(t1 == *r1);
MyTable4 t4;
t4.add();
t4[0].mix.set_subtable(t2);
MyTable2::Ref r2 = unchecked_cast<MyTable2>(t4[0].mix.get_subtable());
CHECK(t2 == *r2);
}
TEST(Table_SetMethod)
{
MyTable1 t;
t.add(8, 9);
CHECK_EQUAL(t[0].val, 8);
CHECK_EQUAL(t[0].val2, 9);
t.set(0, 2, 4);
CHECK_EQUAL(t[0].val, 2);
CHECK_EQUAL(t[0].val2, 4);
}
namespace {
REALM_TABLE_2(TableDateAndBinary,
date, DateTime,
bin, Binary)
} // anonymous namespace
TEST(Table_DateAndBinary)
{
{
TableDateAndBinary t;
const size_t size = 10;
char data[size];
for (size_t i=0; i<size; ++i) data[i] = (char)i;
t.add(8, BinaryData(data, size));
CHECK_EQUAL(t[0].date, 8);
CHECK_EQUAL(t[0].bin.size(), size);
CHECK(std::equal(t[0].bin.data(), t[0].bin.data()+size, data));
}
// Test that 64-bit dates are preserved
{
TableDateAndBinary t;
int64_t date = std::numeric_limits<int64_t>::max() - 400;
t.add(date, BinaryData(""));
CHECK_EQUAL(t[0].date.get().get_datetime(), date);
}
}
// Test for a specific bug found: Calling clear on a group with a table with a subtable
TEST(Table_ClearWithSubtableAndGroup)
{
Group group;
TableRef table = group.add_table("test");
DescriptorRef sub_1;
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_column(type_Table, "sub", &sub_1);
sub_1->add_column(type_Int, "num");
CHECK_EQUAL(2, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_string(0, 0, "Foo");
CHECK_EQUAL(0, table->get_subtable_size(1, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(1, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 123);
CHECK_EQUAL(123, subtable->get_int(0, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(1, 0));
table->clear();
}
//set a subtable in an already exisitng row by providing an existing subtable as the example to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample2?
TEST(Table_SetSubTableByExample1)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// create a freestanding table to be used as a source by set_subtable
Table sub = Table();
sub.add_column(type_Int,"sub_first");
sub.add_column(type_String,"sub_second");
sub.add_empty_row();
sub.set_int(0,0,42);
sub.set_string(1,0,"forty two");
sub.add_empty_row();
sub.set_int(0,1,3);
sub.set_string(1,1,"PI");
// Get the sub-table back for inspection
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
//add a subtable into the row, resembling the sub we just created
table->set_subtable(2,0,&sub);
TableRef subtable2 = table->get_subtable(2, 0);
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1,1));
}
}
//In the tableview class, set a subtable in an already exisitng row by providing an existing subtable as the example to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample1?
TEST(Table_SetSubTableByExample2)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add two rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->insert_empty_row(1);
table->set_int(0, 1, 8);
table->set_string(1, 1, "Hi!, Hello?");
Table sub = Table();
sub.add_column(type_Int,"sub_first");
sub.add_column(type_String,"sub_second");
sub.add_empty_row();
sub.set_int(0,0,42);
sub.set_string(1,0,"forty two");
sub.add_empty_row();
sub.set_int(0,1,3);
sub.set_string(1,1,"PI");
//create a tableview with the table as source
TableView view = table->find_all_int(0,8);//select the second of the two rows
// Verify the sub table is empty
{
TableRef subtable = view.get_subtable(2, 0);
CHECK(subtable->is_empty());
//add a subtable into the second table row (first view row), resembling the sub we just created
view.set_subtable(2,0,&sub);
TableRef subtable2 = view.get_subtable(2, 0);//fetch back the subtable from the view
CHECK_EQUAL(false, subtable->is_empty());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1,1));
TableRef subtable3 = table->get_subtable(2, 1);//fetch back the subtable from the table.
CHECK_EQUAL(42, subtable3->get_int(0, 0));
CHECK_EQUAL("forty two", subtable3->get_string(1, 0));
CHECK_EQUAL(3, subtable3->get_int(0, 1));
CHECK_EQUAL("PI", subtable3->get_string(1,1));
}
}
TEST(Table_HasSharedSpec)
{
MyTable2 table1;
CHECK(!table1.has_shared_type());
Group g;
MyTable2::Ref table2 = g.add_table<MyTable2>("foo");
CHECK(!table2->has_shared_type());
table2->add();
CHECK(table2[0].subtab->has_shared_type());
// Subtable in mixed column
TestTableMX::Ref table3 = g.add_table<TestTableMX>("bar");
CHECK(!table3->has_shared_type());
table3->add();
table3[0].first.set_subtable<MyTable2>();
MyTable2::Ref table4 = table3[0].first.get_subtable<MyTable2>();
CHECK(table4);
CHECK(!table4->has_shared_type());
table4->add();
CHECK(!table4->has_shared_type());
CHECK(table4[0].subtab->has_shared_type());
}
namespace {
REALM_TABLE_3(TableAgg,
c_int, Int,
c_float, Float,
c_double, Double)
// TODO: Bool? DateTime
} // anonymous namespace
#if TEST_DURATION > 0
#define TBL_SIZE REALM_MAX_BPNODE_SIZE*10
#else
#define TBL_SIZE 10
#endif
TEST(Table_Aggregates)
{
TableAgg table;
int64_t i_sum = 0;
double f_sum = 0;
double d_sum = 0;
for (int i = 0; i < TBL_SIZE; i++) {
table.add(5987654, 4.0f, 3.0);
i_sum += 5987654;
f_sum += 4.0f;
d_sum += 3.0;
}
table.add(1, 1.1f, 1.2);
table.add(987654321, 11.0f, 12.0);
table.add(5, 4.0f, 3.0);
i_sum += 1 + 987654321 + 5;
f_sum += double(1.1f) + double(11.0f) + double(4.0f);
d_sum += 1.2 + 12.0 + 3.0;
double size = TBL_SIZE + 3;
double epsilon = std::numeric_limits<double>::epsilon();
// minimum
CHECK_EQUAL(1, table.column().c_int.minimum());
CHECK_EQUAL(1.1f, table.column().c_float.minimum());
CHECK_EQUAL(1.2, table.column().c_double.minimum());
// maximum
CHECK_EQUAL(987654321, table.column().c_int.maximum());
CHECK_EQUAL(11.0f, table.column().c_float.maximum());
CHECK_EQUAL(12.0, table.column().c_double.maximum());
// sum
CHECK_APPROXIMATELY_EQUAL(double(i_sum), double(table.column().c_int.sum()), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum, table.column().c_float.sum(), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum, table.column().c_double.sum(), 10*epsilon);
// average
CHECK_APPROXIMATELY_EQUAL(i_sum/size, table.column().c_int.average(), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum/size, table.column().c_float.average(), 10*epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum/size, table.column().c_double.average(), 10*epsilon);
}
namespace {
REALM_TABLE_1(TableAgg2,
c_count, Int)
} // anonymous namespace
TEST(Table_Aggregates2)
{
TableAgg2 table;
int c = -420;
int s = 0;
while (c < -20) {
table.add(c);
s += c;
c++;
}
CHECK_EQUAL(-420, table.column().c_count.minimum());
CHECK_EQUAL(-21, table.column().c_count.maximum());
CHECK_EQUAL(s, table.column().c_count.sum());
}
// Test Table methods max, min, avg, sum, on both nullable and non-nullable columns
TEST(Table_Aggregates3)
{
bool nullable = false;
for (int i = 0; i < 2; i++) {
// First we test everything with columns being nullable and with each column having at least 1 null
// Then we test everything with non-nullable columns where the null entries will instead be just
// 0, 0.0, etc.
nullable = (i == 1);
Group g;
TableRef table = g.add_table("Inventory");
table->insert_column(0, type_Int, "Price", nullable);
table->insert_column(1, type_Float, "Shipping", nullable);
table->insert_column(2, type_Double, "Rating", nullable);
table->insert_column(3, type_DateTime, "Delivery date", nullable);
table->add_empty_row(3);
table->set_int(0, 0, 1);
// table->set_null(0, 1);
table->set_int(0, 2, 3);
// table->set_null(1, 0);
// table->set_null(1, 1);
table->set_float(1, 2, 30.f);
table->set_double(2, 0, 1.1);
table->set_double(2, 1, 2.2);
// table->set_null(2, 2);
table->set_datetime(3, 0, DateTime(2016, 2, 2));
// table->set_null(3, 1);
table->set_datetime(3, 2, DateTime(2016, 6, 6));
size_t count;
size_t pos;
if (i == 1) {
// This i == 1 is the NULLABLE case where columns are nullable
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_datetime(3, &pos), DateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0, &pos), 1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_double(2, &pos), 1.1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_datetime(3, &pos), DateTime(2016, 2, 2));
CHECK_EQUAL(pos, 0);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3) / 2., 0.01);
CHECK_EQUAL(count, 2);
count = 123;
CHECK_EQUAL(table->average_float(1, &count), 30.f);
CHECK_EQUAL(count, 1);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2) / 2., 0.01);
CHECK_EQUAL(count, 2);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
else {
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_datetime(3, &pos), DateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0, &pos), 0);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->minimum_float(1, &pos), 0.f);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_double(2, &pos), 0.);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_datetime(3, &pos), DateTime(0));
CHECK_EQUAL(pos, 1);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3 + 0) / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_float(1, &count), 30.f / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2 + 0.) / 3., 0.01);
CHECK_EQUAL(count, 3);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
}
}
TEST(Table_LanguageBindings)
{
Table* table = LangBindHelper::new_table();
CHECK(table->is_attached());
table->add_column(type_Int, "i");
table->insert_empty_row(0);
table->set_int(0, 0, 10);
table->insert_empty_row(1);
table->set_int(0, 1, 12);
Table* table2 = LangBindHelper::copy_table(*table);
CHECK(table2->is_attached());
CHECK(*table == *table2);
LangBindHelper::unbind_table_ptr(table);
LangBindHelper::unbind_table_ptr(table2);
}
TEST(Table_MultipleColumn)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "first");
CHECK_EQUAL(table.get_column_count(), 2);
CHECK_EQUAL(table.get_column_index("first"), 0);
}
TEST(Table_FormerLeakCase)
{
Table sub;
sub.add_column(type_Int, "a");
Table root;
DescriptorRef subdesc;
root.add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "a");
root.add_empty_row(1);
root.set_subtable(0, 0, &sub);
root.set_subtable(0, 0, 0);
}
namespace {
REALM_TABLE_3(TablePivotAgg,
sex, String,
age, Int,
hired, Bool)
} // anonymous namespace
TEST(Table_Pivot)
{
size_t count = 1717;
TablePivotAgg table;
int64_t age_sum[2] = {0, 0};
int64_t age_cnt[2] = {0, 0};
int64_t age_min[2];
int64_t age_max[2];
double age_avg[2];
for (size_t i = 0; i < count; ++i) {
size_t sex = i % 2;
int64_t age = 3 + (i%117);
table.add((sex==0) ? "Male" : "Female", age, true);
age_sum[sex] += age;
age_cnt[sex] += 1;
if ((i < 2) || age < age_min[sex])
age_min[sex] = age;
if ((i < 2) || age > age_max[sex])
age_max[sex] = age;
}
for (size_t sex = 0; sex < 2; ++sex) {
age_avg[sex] = double(age_sum[sex]) / double(age_cnt[sex]);
}
for (int i = 0; i < 2; ++i) {
Table result_count;
table.aggregate(0, 1, Table::aggr_count, result_count);
CHECK_EQUAL(2, result_count.get_column_count());
CHECK_EQUAL(2, result_count.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_cnt[sex], result_count.get_int(1, sex));
}
Table result_sum;
table.aggregate(0, 1, Table::aggr_sum, result_sum);
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_sum[sex], result_sum.get_int(1, sex));
}
Table result_avg;
table.aggregate(0, 1, Table::aggr_avg, result_avg);
if ((false)) {
std::ostringstream ss;
result_avg.to_string(ss);
std::cerr << "\nMax:\n" << ss.str();
}
CHECK_EQUAL(2, result_avg.get_column_count());
CHECK_EQUAL(2, result_avg.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_avg[sex], result_avg.get_double(1, sex));
}
Table result_min;
table.aggregate(0, 1, Table::aggr_min, result_min);
CHECK_EQUAL(2, result_min.get_column_count());
CHECK_EQUAL(2, result_min.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_min[sex], result_min.get_int(1, sex));
}
Table result_max;
table.aggregate(0, 1, Table::aggr_max, result_max);
CHECK_EQUAL(2, result_max.get_column_count());
CHECK_EQUAL(2, result_max.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_max[sex], result_max.get_int(1, sex));
}
// Test with enumerated strings in second loop
table.optimize();
}
}
namespace {
void compare_table_with_slice(TestResults& test_results, const Table& table,
const Table& slice, size_t offset, size_t size)
{
ConstDescriptorRef table_desc = table.get_descriptor();
ConstDescriptorRef slice_desc = slice.get_descriptor();
CHECK(*table_desc == *slice_desc);
if (*table_desc != *slice_desc)
return;
size_t num_cols = table.get_column_count();
for (size_t col_i = 0; col_i != num_cols; ++col_i) {
DataType type = table.get_column_type(col_i);
switch (type) {
case type_Int:
case type_Link:
for (size_t i = 0; i != size; ++i) {
int_fast64_t v_1 = table.get_int(col_i, offset + i);
int_fast64_t v_2 = slice.get_int(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Bool:
for (size_t i = 0; i != size; ++i) {
bool v_1 = table.get_bool(col_i, offset + i);
bool v_2 = slice.get_bool(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Float:
for (size_t i = 0; i != size; ++i) {
float v_1 = table.get_float(col_i, offset + i);
float v_2 = slice.get_float(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Double:
for (size_t i = 0; i != size; ++i) {
double v_1 = table.get_double(col_i, offset + i);
double v_2 = slice.get_double(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_String:
for (size_t i = 0; i != size; ++i) {
StringData v_1 = table.get_string(col_i, offset + i);
StringData v_2 = slice.get_string(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Binary:
for (size_t i = 0; i != size; ++i) {
BinaryData v_1 = table.get_binary(col_i, offset + i);
BinaryData v_2 = slice.get_binary(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_DateTime:
for (size_t i = 0; i != size; ++i) {
DateTime v_1 = table.get_datetime(col_i, offset + i);
DateTime v_2 = slice.get_datetime(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Table:
for (size_t i = 0; i != size; ++i) {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
}
break;
case type_Mixed:
for (size_t i = 0; i != size; ++i) {
Mixed v_1 = table.get_mixed(col_i, offset + i);
Mixed v_2 = slice.get_mixed(col_i, i);
CHECK_EQUAL(v_1.get_type(), v_2.get_type());
if (v_1.get_type() == v_2.get_type()) {
switch (v_1.get_type()) {
case type_Int:
CHECK_EQUAL(v_1.get_int(), v_2.get_int());
break;
case type_Bool:
CHECK_EQUAL(v_1.get_bool(), v_2.get_bool());
break;
case type_Float:
CHECK_EQUAL(v_1.get_float(), v_2.get_float());
break;
case type_Double:
CHECK_EQUAL(v_1.get_double(), v_2.get_double());
break;
case type_String:
CHECK_EQUAL(v_1.get_string(), v_2.get_string());
break;
case type_Binary:
CHECK_EQUAL(v_1.get_binary(), v_2.get_binary());
break;
case type_DateTime:
CHECK_EQUAL(v_1.get_datetime(), v_2.get_datetime());
break;
case type_Table: {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
break;
}
case type_Mixed:
case type_Link:
case type_LinkList:
REALM_ASSERT(false);
}
}
}
break;
case type_LinkList:
break;
}
}
}
void test_write_slice_name(TestResults& test_results, const Table& table,
StringData expect_name, bool override_name)
{
size_t offset = 0, size = 0;
std::ostringstream out;
if (override_name) {
table.write(out, offset, size, expect_name);
}
else {
table.write(out, offset, size);
}
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table(expect_name);
CHECK(slice);
}
void test_write_slice_contents(TestResults& test_results, const Table& table,
size_t offset, size_t size)
{
std::ostringstream out;
table.write(out, offset, size);
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table("test");
CHECK(slice);
if (slice) {
size_t remaining_size = table.size() - offset;
size_t size_2 = size;
if (size_2 > remaining_size)
size_2 = remaining_size;
CHECK_EQUAL(size_2, slice->size());
if (size_2 == slice->size())
compare_table_with_slice(test_results, table, *slice, offset, size_2);
}
}
} // anonymous namespace
TEST(Table_WriteSlice)
{
// check that the name of the written table is as expected
{
Table table;
test_write_slice_name(test_results, table, "", false);
test_write_slice_name(test_results, table, "foo", true); // Override
test_write_slice_name(test_results, table, "", true); // Override
}
{
Group group;
TableRef table = group.add_table("test");
test_write_slice_name(test_results, *table, "test", false);
test_write_slice_name(test_results, *table, "foo", true); // Override
test_write_slice_name(test_results, *table, "", true); // Override
}
// Run through a 3-D matrix of table sizes, slice offsets, and
// slice sizes. Each test involves a table with columns of each
// possible type.
#ifdef REALM_DEBUG
int table_sizes[] = { 0, 1, 2, 3, 5, 9, 27, 81, 82, 135 };
#else
int table_sizes[] = { 0, 1, 2, 3, 5, 9, 27, 81, 82, 243, 729, 2187, 6561 };
#endif
int num_sizes = sizeof table_sizes / sizeof *table_sizes;
for (int table_size_i = 0; table_size_i != num_sizes; ++table_size_i) {
int table_size = table_sizes[table_size_i];
Group group;
TableRef table = group.add_table("test");
bool fixed_subtab_sizes = true;
setup_multi_table(*table, table_size, 1, fixed_subtab_sizes);
for (int offset_i = 0; offset_i != num_sizes; ++offset_i) {
int offset = table_sizes[offset_i];
if (offset > table_size)
break;
for (int size_i = 0; size_i != num_sizes; ++size_i) {
int size = table_sizes[size_i];
// This also checks that the range can extend beyond
// end of table
test_write_slice_contents(test_results, *table, offset, size);
if (offset + size > table_size)
break;
}
}
}
}
TEST(Table_Parent)
{
TableRef table = Table::create();
CHECK_EQUAL(TableRef(), table->get_parent_table());
CHECK_EQUAL(realm::npos, table->get_parent_row_index()); // Not a subtable
CHECK_EQUAL(realm::npos, table->get_index_in_group()); // Not a group-level table
DescriptorRef subdesc;
table->add_column(type_Table, "", &subdesc);
table->add_column(type_Mixed, "");
subdesc->add_column(type_Int, "");
table->add_empty_row(2);
table->set_mixed(1, 0, Mixed::subtable_tag());
table->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab;
size_t column_ndx = 0;
subtab = table->get_subtable(0,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after new
// column is insert.
table->insert_column(0, type_Int, "");
subtab = table->get_subtable(1,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(2,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(2,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after inserted
// column is removed.
table->remove_column(0);
subtab = table->get_subtable(0,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1,0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1,1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
}
TEST(Table_RegularSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
DescriptorRef subdesc;
parent->add_column(type_Table, "a", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
TableRef subtab_0_0 = parent->get_subtable(0,0);
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
parent->add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
subtab_0_0->add_empty_row();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
TableRef subtab_0_1 = parent->get_subtable(0,1);
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
TableRef subtab_1_0 = parent->get_subtable(1,0);
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
TableRef subtab_1_1 = parent->get_subtable(1,1);
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Float, "f");
subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int (0, 0, 10000);
subtab_0_0->set_float (1, 0, 10010.0f);
subtab_1_1->set_int (0, 0, 11100);
subtab_1_1->set_double (1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11100, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double (1,0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int (0, 0, 10001);
subtab_0_0->set_float (1, 0, 10011.0f);
subtab_1_1->set_int (0, 0, 11101);
subtab_1_1->set_double (1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11101, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
subtab_0_0->set_int (0, 0, 10002);
subtab_0_0->set_float (1, 0, 10012.0f);
subtab_1_1->set_int (0, 0, 11102);
subtab_1_1->set_double (1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11102, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int (0, 0, 10003);
subtab_0_0->set_float (1, 0, 10013.0f);
subtab_1_1->set_int (0, 0, 11103);
subtab_1_1->set_double (1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11103, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10004);
subtab_0_0->set_float (1, 0, 10014.0f);
subtab_1_1->set_int (0, 0, 11104);
subtab_1_1->set_double (1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11104, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int (0, 0, 10005);
subtab_0_0->set_float (1, 0, 10015.0f);
subtab_1_1->set_int (0, 0, 11105);
subtab_1_1->set_double (1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11105, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10006);
subtab_0_0->set_float (1, 0, 10016.0f);
subtab_1_1->set_int (0, 0, 11106);
subtab_1_1->set_double (1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11106, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int (0, 0, 10007);
subtab_0_0->set_float (1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK( subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
parent->remove_column(1);
subtab_0_0->set_int (0, 0, 10008);
subtab_0_0->set_float (1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
// Clear subtable
parent->clear_subtable(0,0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Table, "c", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0,0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK( subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Table, "d", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0,0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0,0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_MixedSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_column(type_Int, "x");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
subtab_0_0->add_empty_row();
parent->add_column(type_Mixed, "b");
parent->set_mixed(1, 0, Mixed::subtable_tag());
TableRef subtab_1_0 = parent->get_subtable(1,0);
subtab_1_0->add_column(type_Int, "x");
parent->add_empty_row();
parent->set_mixed(0, 1, Mixed::subtable_tag());
TableRef subtab_0_1 = parent->get_subtable(0,1);
subtab_0_1->add_column(type_Int, "x");
parent->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_column(type_Int, "x");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subtab_0_0->add_column(type_Float, "f");
subtab_0_1->add_column(type_Float, "f");
subtab_1_0->add_column(type_Double, "d");
subtab_1_1->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int (0, 0, 10000);
subtab_0_0->set_float (1, 0, 10010.0f);
subtab_1_1->set_int (0, 0, 11100);
subtab_1_1->set_double (1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11100, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double (1,0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int (0, 0, 10001);
subtab_0_0->set_float (1, 0, 10011.0f);
subtab_1_1->set_int (0, 0, 11101);
subtab_1_1->set_double (1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11101, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
parent->set_mixed(3, 2, "Lopadotemachoselachogaleokranioleipsanodrimhypotrimmatosilphio"
"paraomelitokatakechymenokichlepikossyphophattoperisteralektryonopte"
"kephalliokigklopeleiolagoiosiraiobaphetraganopterygon");
subtab_0_0->set_int (0, 0, 10002);
subtab_0_0->set_float (1, 0, 10012.0f);
subtab_1_1->set_int (0, 0, 11102);
subtab_1_1->set_double (1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11102, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int (0, 0, 10003);
subtab_0_0->set_float (1, 0, 10013.0f);
subtab_1_1->set_int (0, 0, 11103);
subtab_1_1->set_double (1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11103, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3,3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10004);
subtab_0_0->set_float (1, 0, 10014.0f);
subtab_1_1->set_int (0, 0, 11104);
subtab_1_1->set_double (1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11104, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1,1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1,2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2,1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2,2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int (0, 0, 10005);
subtab_0_0->set_float (1, 0, 10015.0f);
subtab_1_1->set_int (0, 0, 11105);
subtab_1_1->set_double (1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11105, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int (0, 0, 10006);
subtab_0_0->set_float (1, 0, 10016.0f);
subtab_1_1->set_int (0, 0, 11106);
subtab_1_1->set_double (1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(11106, subtab_1_1->get_int (0,0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0,1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1,1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int (0, 0, 10007);
subtab_0_0->set_float (1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK( subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1,0));
parent->remove_column(1);
subtab_0_0->set_int (0, 0, 10008);
subtab_0_0->set_float (1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK( subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int (0,0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float (1,0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0,0));
// Remove subtable
parent->clear_subtable(0,0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(!subtab_0_0->is_attached());
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Mixed, "c");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
CHECK(subtab_0_0);
CHECK(subtab_0_1);
CHECK(subtab_1_0);
CHECK(subtab_1_1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0,0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK( subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0,0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Mixed, "d");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_1 = parent->get_subtable(0,1);
subtab_1_0 = parent->get_subtable(1,0);
subtab_1_1 = parent->get_subtable(1,1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0,0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0,0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0,0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_RowAccessor)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Int, "int");
table.add_column(type_Bool, "bool");
table.add_column(type_Float, "");
table.add_column(type_Double, "");
table.add_column(type_String, "");
table.add_column(type_Binary, "", true);
table.add_column(type_DateTime, "");
table.add_column(type_Table, "", &subdesc);
table.add_column(type_Mixed, "");
subdesc->add_column(type_Int, "i");
table.add_empty_row(2);
BinaryData bin("bin", 3);
Table empty_subtab;
empty_subtab.add_column(type_Int, "i");
Table one_subtab;
one_subtab.add_column(type_Int, "i");
one_subtab.add_empty_row(1);
one_subtab.set_int(0, 0, 19);
Table two_subtab;
two_subtab.add_column(type_Int, "i");
two_subtab.add_empty_row(1);
two_subtab.set_int(0, 0, 29);
table.set_int (0, 1, 4923);
table.set_bool (1, 1, true);
table.set_float (2, 1, 5298.0f);
table.set_double (3, 1, 2169.0);
table.set_string (4, 1, "str");
table.set_binary (5, 1, bin);
table.set_datetime (6, 1, 7739);
table.set_subtable (7, 1, &one_subtab);
table.set_mixed (8, 1, Mixed("mix"));
// Check getters for `RowExpr`
{
CHECK_EQUAL(9, table[0].get_column_count());
CHECK_EQUAL(type_Int, table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, table[0].get_column_type(1));
CHECK_EQUAL("int", table[0].get_column_name(0));
CHECK_EQUAL("bool", table[0].get_column_name(1));
CHECK_EQUAL(0, table[0].get_column_index("int"));
CHECK_EQUAL(1, table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), table[0].get_int (0));
CHECK_EQUAL(bool(), table[0].get_bool (1));
CHECK_EQUAL(float(), table[0].get_float (2));
CHECK_EQUAL(double(), table[0].get_double (3));
CHECK_EQUAL(StringData(""), table[0].get_string (4));
CHECK_EQUAL(BinaryData(), table[0].get_binary (5));
CHECK_EQUAL(DateTime(), table[0].get_datetime (6));
CHECK_EQUAL(0, table[0].get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), table[0].get_mixed (8));
CHECK_EQUAL(type_Int, table[0].get_mixed_type (8));
CHECK_EQUAL(4923, table[1].get_int (0));
CHECK_EQUAL(true, table[1].get_bool (1));
CHECK_EQUAL(5298.0f, table[1].get_float (2));
CHECK_EQUAL(2169.0, table[1].get_double (3));
CHECK_EQUAL("str", table[1].get_string (4));
CHECK_EQUAL(bin, table[1].get_binary (5));
CHECK_EQUAL(DateTime(7739), table[1].get_datetime (6));
CHECK_EQUAL(1, table[1].get_subtable_size (7));
CHECK_EQUAL("mix", table[1].get_mixed (8));
CHECK_EQUAL(type_String, table[1].get_mixed_type (8));
TableRef subtab_0 = table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRowExpr`
{
const Table& const_table = table;
CHECK_EQUAL(9, const_table[0].get_column_count());
CHECK_EQUAL(type_Int, const_table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, const_table[0].get_column_type(1));
CHECK_EQUAL("int", const_table[0].get_column_name(0));
CHECK_EQUAL("bool", const_table[0].get_column_name(1));
CHECK_EQUAL(0, const_table[0].get_column_index("int"));
CHECK_EQUAL(1, const_table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_int (0));
CHECK_EQUAL(bool(), const_table[0].get_bool (1));
CHECK_EQUAL(float(), const_table[0].get_float (2));
CHECK_EQUAL(double(), const_table[0].get_double (3));
CHECK_EQUAL(StringData(""), const_table[0].get_string (4));
CHECK_EQUAL(BinaryData(), const_table[0].get_binary (5));
CHECK_EQUAL(DateTime(), const_table[0].get_datetime (6));
CHECK_EQUAL(0, const_table[0].get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_mixed (8));
CHECK_EQUAL(type_Int, const_table[0].get_mixed_type (8));
CHECK_EQUAL(4923, const_table[1].get_int (0));
CHECK_EQUAL(true, const_table[1].get_bool (1));
CHECK_EQUAL(5298.0f, const_table[1].get_float (2));
CHECK_EQUAL(2169.0, const_table[1].get_double (3));
CHECK_EQUAL("str", const_table[1].get_string (4));
CHECK_EQUAL(bin, const_table[1].get_binary (5));
CHECK_EQUAL(DateTime(7739), const_table[1].get_datetime (6));
CHECK_EQUAL(1, const_table[1].get_subtable_size (7));
CHECK_EQUAL("mix", const_table[1].get_mixed (8));
CHECK_EQUAL(type_String, const_table[1].get_mixed_type (8));
ConstTableRef subtab_0 = const_table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = const_table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(9, row_0.get_column_count());
CHECK_EQUAL(type_Int, row_0.get_column_type(0));
CHECK_EQUAL(type_Bool, row_0.get_column_type(1));
CHECK_EQUAL("int", row_0.get_column_name(0));
CHECK_EQUAL("bool", row_0.get_column_name(1));
CHECK_EQUAL(0, row_0.get_column_index("int"));
CHECK_EQUAL(1, row_0.get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
TableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const Row`
{
const Row row_0 = table[0];
const Row row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRow`
{
ConstRow row_0 = table[0];
ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const ConstRow` (double constness)
{
const ConstRow row_0 = table[0];
const ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int (0));
CHECK_EQUAL(bool(), row_0.get_bool (1));
CHECK_EQUAL(float(), row_0.get_float (2));
CHECK_EQUAL(double(), row_0.get_double (3));
CHECK_EQUAL(StringData(""), row_0.get_string (4));
CHECK_EQUAL(BinaryData(), row_0.get_binary (5));
CHECK_EQUAL(DateTime(), row_0.get_datetime (6));
CHECK_EQUAL(0, row_0.get_subtable_size (7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed (8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type (8));
CHECK_EQUAL(4923, row_1.get_int (0));
CHECK_EQUAL(true, row_1.get_bool (1));
CHECK_EQUAL(5298.0f, row_1.get_float (2));
CHECK_EQUAL(2169.0, row_1.get_double (3));
CHECK_EQUAL("str", row_1.get_string (4));
CHECK_EQUAL(bin, row_1.get_binary (5));
CHECK_EQUAL(DateTime(7739), row_1.get_datetime (6));
CHECK_EQUAL(1, row_1.get_subtable_size (7));
CHECK_EQUAL("mix", row_1.get_mixed (8));
CHECK_EQUAL(type_String, row_1.get_mixed_type (8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
}
// Check setters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
row_0.set_int (0, 5651);
row_0.set_bool (1, true);
row_0.set_float (2, 8397.0f);
row_0.set_double (3, 1937.0);
row_0.set_string (4, "foo");
row_0.set_binary (5, bin);
row_0.set_datetime (6, DateTime(9992));
row_0.set_subtable (7, &one_subtab);
row_0.set_mixed (8, Mixed(3637.0f));
row_1.set_int (0, int_fast64_t());
row_1.set_bool (1, bool());
row_1.set_float (2, float());
row_1.set_double (3, double());
row_1.set_string (4, StringData(""));
row_1.set_binary (5, BinaryData());
row_1.set_datetime (6, DateTime());
row_1.set_subtable (7, 0);
row_1.set_mixed (8, Mixed());
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(5651, table.get_int (0,0));
CHECK_EQUAL(true, table.get_bool (1,0));
CHECK_EQUAL(8397.0f, table.get_float (2,0));
CHECK_EQUAL(1937.0, table.get_double (3,0));
CHECK_EQUAL("foo", table.get_string (4,0));
CHECK_EQUAL(bin, table.get_binary (5,0));
CHECK_EQUAL(DateTime(9992), table.get_datetime (6,0));
CHECK_EQUAL(3637.0f, table.get_mixed (8,0));
CHECK_EQUAL(int_fast64_t(), table.get_int (0,1));
CHECK_EQUAL(bool(), table.get_bool (1,1));
CHECK_EQUAL(float(), table.get_float (2,1));
CHECK_EQUAL(double(), table.get_double (3,1));
CHECK_EQUAL(StringData(""), table.get_string (4,1));
CHECK_EQUAL(BinaryData(), table.get_binary (5,1));
CHECK_EQUAL(DateTime(), table.get_datetime (6,1));
CHECK_EQUAL(int_fast64_t(), table.get_mixed (8,1));
TableRef subtab_0 = table.get_subtable(7,0);
CHECK_EQUAL(19, subtab_0->get_int(0,0));
CHECK(*subtab_0 == one_subtab);
TableRef subtab_1 = table.get_subtable(7,1);
CHECK(*subtab_1 == empty_subtab);
row_0.set_mixed_subtable(8, 0);
row_1.set_mixed_subtable(8, &two_subtab);
subtab_0 = table.get_subtable(8,0);
subtab_1 = table.get_subtable(8,1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK(*subtab_0 == Table());
CHECK_EQUAL(29, subtab_1->get_int(0,0));
CHECK(*subtab_1 == two_subtab);
}
// Check setters for `RowExpr`
{
table[0].set_int (0, int_fast64_t());
table[0].set_bool (1, bool());
table[0].set_float (2, float());
table[0].set_double (3, double());
table[0].set_string (4, StringData(""));
table[0].set_binary (5, BinaryData());
table[0].set_datetime (6, DateTime());
table[0].set_subtable (7, 0);
table[0].set_mixed (8, Mixed());
table[1].set_int (0, 5651);
table[1].set_bool (1, true);
table[1].set_float (2, 8397.0f);
table[1].set_double (3, 1937.0);
table[1].set_string (4, "foo");
table[1].set_binary (5, bin);
table[1].set_datetime (6, DateTime(9992));
table[1].set_subtable (7, &one_subtab);
table[1].set_mixed (8, Mixed(3637.0f));
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(int_fast64_t(), table.get_int (0,0));
CHECK_EQUAL(bool(), table.get_bool (1,0));
CHECK_EQUAL(float(), table.get_float (2,0));
CHECK_EQUAL(double(), table.get_double (3,0));
CHECK_EQUAL(StringData(""), table.get_string (4,0));
CHECK_EQUAL(BinaryData(), table.get_binary (5,0));
CHECK_EQUAL(DateTime(), table.get_datetime (6,0));
CHECK_EQUAL(int_fast64_t(), table.get_mixed (8,0));
CHECK_EQUAL(5651, table.get_int (0,1));
CHECK_EQUAL(true, table.get_bool (1,1));
CHECK_EQUAL(8397.0f, table.get_float (2,1));
CHECK_EQUAL(1937.0, table.get_double (3,1));
CHECK_EQUAL("foo", table.get_string (4,1));
CHECK_EQUAL(bin, table.get_binary (5,1));
CHECK_EQUAL(DateTime(9992), table.get_datetime (6,1));
CHECK_EQUAL(3637.0f, table.get_mixed (8,1));
TableRef subtab_0 = table.get_subtable(7,0);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table.get_subtable(7,1);
CHECK_EQUAL(19, subtab_1->get_int(0,0));
CHECK(*subtab_1 == one_subtab);
table[0].set_mixed_subtable(8, &two_subtab);
table[1].set_mixed_subtable(8, 0);
subtab_0 = table.get_subtable(8,0);
subtab_1 = table.get_subtable(8,1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK_EQUAL(29, subtab_0->get_int(0,0));
CHECK(*subtab_0 == two_subtab);
CHECK(*subtab_1 == Table());
}
// Check that we can also create ConstRow's from `const Table`
{
const Table& const_table = table;
ConstRow row_0 = const_table[0];
ConstRow row_1 = const_table[1];
CHECK_EQUAL(0, row_0.get_int(0));
CHECK_EQUAL(5651, row_1.get_int(0));
}
// Check that we can get the table and the row index from a Row
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(&table, row_0.get_table());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
}
}
TEST(Table_RowAccessorLinks)
{
Group group;
TableRef target_table = group.add_table("target");
target_table->add_column(type_Int, "");
target_table->add_empty_row(16);
TableRef origin_table = group.add_table("origin");
origin_table->add_column_link(type_Link, "", *target_table);
origin_table->add_column_link(type_LinkList, "", *target_table);
origin_table->add_empty_row(2);
Row source_row_1 = origin_table->get(0);
Row source_row_2 = origin_table->get(1);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
// Set links
source_row_1.set_link(0, 7);
source_row_2.set_link(0, 13);
CHECK(!source_row_1.is_null_link(0));
CHECK(!source_row_2.is_null_link(0));
CHECK_EQUAL(7, source_row_1.get_link(0));
CHECK_EQUAL(13, source_row_2.get_link(0));
CHECK_EQUAL(1, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(7).get_backlink(*origin_table, 0, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink(*origin_table, 0, 0));
// Nullify links
source_row_1.nullify_link(0);
source_row_2.nullify_link(0);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
// Add stuff to link lists
LinkViewRef link_list_1 = source_row_1.get_linklist(1);
LinkViewRef link_list_2 = source_row_2.get_linklist(1);
link_list_1->add(15);
link_list_2->add(11);
link_list_2->add(15);
CHECK(!source_row_1.linklist_is_empty(1));
CHECK(!source_row_2.linklist_is_empty(1));
CHECK_EQUAL(1, source_row_1.get_link_count(1));
CHECK_EQUAL(2, source_row_2.get_link_count(1));
CHECK_EQUAL(1, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(2, target_table->get(15).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(1, target_table->get(11).get_backlink(*origin_table, 1, 0));
size_t back_link_1 = target_table->get(15).get_backlink(*origin_table, 1, 0);
size_t back_link_2 = target_table->get(15).get_backlink(*origin_table, 1, 1);
CHECK((back_link_1 == 0 && back_link_2 == 1) || (back_link_1 == 1 && back_link_2 == 0));
// Clear link lists
link_list_1->clear();
link_list_2->clear();
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
}
TEST(Table_RowAccessorDetach)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
Row row = table[0];
CHECK(row.is_attached());
row.detach();
CHECK(!row.is_attached());
row = table[0];
CHECK(row.is_attached());
}
TEST(Table_RowAccessorCopyAndAssign)
{
Table table;
const Table& ctable = table;
table.add_column(type_Int, "");
table.add_empty_row(3);
table.set_int(0, 0, 750);
table.set_int(0, 1, 751);
table.set_int(0, 2, 752);
{
// Check copy construction of row accessor from row expression
Row row_1 = table[0]; // Copy construct `Row` from `RowExpr`
ConstRow crow_1 = table[1]; // Copy construct `ConstRow` from `RowExpr`
ConstRow crow_2 = ctable[2]; // Copy construct `ConstRow` from `ConstRowExpr`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
// Check copy construction of row accessor from other row accessor
Row drow_1;
ConstRow dcrow_1;
CHECK(!drow_1.is_attached());
CHECK(!dcrow_1.is_attached());
Row drow_2 = drow_1; // Copy construct `Row` from detached `Row`
ConstRow dcrow_2 = drow_1; // Copy construct `ConstRow` from detached `Row`
ConstRow dcrow_3 = dcrow_1; // Copy construct `ConstRow` from detached `ConstRow`
Row row_2 = row_1; // Copy construct `Row` from attached `Row`
ConstRow crow_3 = row_1; // Copy construct `ConstRow` from attached `Row`
ConstRow crow_4 = crow_1; // Copy construct `ConstRow` from attached `ConstRow`
CHECK(!drow_2.is_attached());
CHECK(!dcrow_2.is_attached());
CHECK(!dcrow_3.is_attached());
CHECK(row_2.is_attached());
CHECK(crow_3.is_attached());
CHECK(crow_4.is_attached());
CHECK(!drow_2.get_table());
CHECK(!dcrow_2.get_table());
CHECK(!dcrow_3.get_table());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(&table, crow_4.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(0, crow_3.get_index());
CHECK_EQUAL(1, crow_4.get_index());
}
table.verify();
// Check assignment of row expression to row accessor
{
Row row;
ConstRow crow_1, crow_2;
row = table[0]; // Assign `RowExpr` to detached `Row`
crow_1 = table[1]; // Assign `RowExpr` to detached `ConstRow`
crow_2 = ctable[2]; // Assign `ConstRowExpr` to detached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row = table[1]; // Assign `RowExpr` to attached `Row`
crow_1 = table[2]; // Assign `RowExpr` to attached `ConstRow`
crow_2 = ctable[0]; // Assign `ConstRowExpr` to attached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(1, row.get_index());
CHECK_EQUAL(2, crow_1.get_index());
CHECK_EQUAL(0, crow_2.get_index());
}
// Check assignment of row accessor to row accessor
{
Row drow, row_1;
ConstRow dcrow, crow_1, crow_2;
row_1 = row_1; // Assign detached `Row` to self
crow_1 = crow_1; // Assign detached `ConstRow` to self
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
row_1 = drow; // Assign detached `Row` to detached `Row`
crow_1 = drow; // Assign detached `Row` to detached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to detached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
Row row_2 = table[0];
Row row_3 = table[1];
ConstRow crow_3 = table[2];
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK(crow_3.is_attached());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, row_3.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(1, row_3.get_index());
CHECK_EQUAL(2, crow_3.get_index());
row_1 = row_2; // Assign attached `Row` to detached `Row`
crow_1 = row_3; // Assign attached `Row` to detached `ConstRow`
crow_2 = crow_3; // Assign attached `ConstRow` to detached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row_1 = row_1; // Assign attached `Row` to self
crow_1 = crow_1; // Assign attached `ConstRow` to self
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
Row row_4 = table[2];
Row row_5 = table[0];
ConstRow crow_4 = table[1];
row_1 = row_4; // Assign attached `Row` to attached `Row`
crow_1 = row_5; // Assign attached `Row` to attached `ConstRow`
crow_2 = crow_4; // Assign attached `ConstRow` to attached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(0, crow_1.get_index());
CHECK_EQUAL(1, crow_2.get_index());
row_1 = drow; // Assign detached `Row` to attached `Row`
crow_1 = drow; // Assign detached `Row` to attached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to attached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
}
}
TEST(Table_RowAccessorCopyConstructionBug)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
BasicRowExpr<Table> row_expr(table[0]);
BasicRow<Table> row_from_expr(row_expr);
BasicRow<Table> row_copy(row_from_expr);
table.remove(0);
CHECK_NOT(row_from_expr.is_attached());
CHECK_NOT(row_copy.is_attached());
}
TEST(Table_RowAccessorAssignMultipleTables)
{
Table tables[2];
for (int i = 0; i < 2; ++i) {
tables[i].add_column(type_Int, "");
tables[i].add_empty_row(3);
tables[i].set_int(0, 0, 750);
tables[i].set_int(0, 1, 751);
tables[i].set_int(0, 2, 752);
}
Row row_1 = tables[0][2];
Row row_2 = tables[1][2];
Row row_3 = tables[0][2];
row_1 = tables[1][2]; // Assign attached `Row` to a different table via RowExpr
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 2);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 1);
row_1 = row_3; // Assign attached `Row` to a different table via Row
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 0);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 0);
}
TEST(Table_RowAccessorRetain)
{
// Create a table with two rows
TableRef parent = Table::create();
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
ConstRow row_1 = (*parent)[0];
ConstRow row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that row insertion does not detach the row accessors, and that the
// row indexes is properly adjusted
parent->insert_empty_row(1); // Between
parent->add_empty_row(); // After
parent->insert_empty_row(0); // Before
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->insert_empty_row(1); // Immediately before row_1
parent->insert_empty_row(5); // Immediately after row_2
parent->insert_empty_row(3); // Immediately after row_1
parent->insert_empty_row(5); // Immediately before row_2
parent->verify();
CHECK_EQUAL(9, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(6, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of rows (other than row_1 and row_2) does not detach
// the row accessors, and that the row indexes is properly adjusted
parent->remove(3); // Immediately after row_1
parent->remove(1); // Immediately before row_1
parent->remove(3); // Immediately before row_2
parent->remove(4); // Immediately after row_2
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->remove(4); // After
parent->remove(0); // Before
parent->remove(1); // Between
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of first row detaches row_1
parent->remove(0);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(!row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(227, row_2.get_int(0));
// Restore first row and recover row_1
parent->insert_empty_row(0);
parent->set_int(0, 0, 27);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of second row detaches row_2
parent->remove(1);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(row_1.is_attached());
CHECK(!row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
// Restore second row and recover row_2
parent->add_empty_row();
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that descriptor modifications do not affect the row accessors (as
// long as we do not remove the last column)
parent->add_column(type_String, "x");
parent->insert_column(0, type_Float, "y");
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(1));
CHECK_EQUAL(227, row_2.get_int(1));
parent->remove_column(0);
parent->remove_column(1);
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of the last column detaches all row accessors
parent->remove_column(0);
parent->verify();
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
// Restore rows and recover row accessors
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that clearing of the table detaches all row accessors
parent->clear();
parent->verify();
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
}
TEST(Table_SubtableRowAccessorsRetain)
{
// Create a mixed and a regular subtable each with one row
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_column(type_Table, "b");
DescriptorRef subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(0,0);
CHECK(mixed && mixed->is_attached());
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
TableRef regular = parent->get_subtable(1,0);
CHECK(regular && regular->is_attached());
regular->add_empty_row();
regular->set_int(0, 0, 29);
CHECK(mixed->size() == 1);
CHECK(regular->size() == 1);
ConstRow row_m = (*mixed)[0];
ConstRow row_r = (*regular)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a mixed subtable are detached if the
// subtable is overridden
parent->set_mixed(0, 0, Mixed("foo"));
CHECK(!mixed->is_attached());
CHECK(regular->is_attached());
CHECK(!row_m.is_attached());
CHECK(row_r.is_attached());
// Restore mixed
parent->set_mixed(0, 0, Mixed::subtable_tag());
mixed = parent->get_subtable(0,0);
CHECK(mixed);
CHECK(mixed->is_attached());
mixed->add_column(type_Int, "mixed_2");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
CHECK(regular->is_attached());
CHECK_EQUAL(1, mixed->size());
CHECK_EQUAL(1, regular->size());
row_m = (*mixed)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a regular subtable are detached if the
// subtable is overridden
parent->set_subtable(1, 0, 0); // Clear
CHECK(mixed->is_attached());
CHECK(regular->is_attached());
CHECK(row_m.is_attached());
CHECK(!row_r.is_attached());
}
TEST(Table_MoveLastOverRetain)
{
// Create three parent tables, each with with 5 rows, and each row
// containing one regular and one mixed subtable
TableRef parent_1, parent_2, parent_3;
for (int i = 0; i < 3; ++i) {
TableRef& parent = i == 0 ? parent_1 : i == 1 ? parent_2 : parent_3;
parent = Table::create();
parent->add_column(type_Table, "a");
parent->add_column(type_Mixed, "b");
DescriptorRef subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row(5);
for (int row_ndx = 0; row_ndx < 5; ++row_ndx) {
TableRef regular = parent->get_subtable(0, row_ndx);
regular->add_empty_row();
regular->set_int(0, 0, 10 + row_ndx);
parent->set_mixed(1, row_ndx, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(1, row_ndx);
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 20 + row_ndx);
}
}
// Use first table to check with accessors on row indexes 0, 1, and 4, but
// none at index 2 and 3.
{
TableRef parent = parent_1;
ConstRow row_0 = (*parent)[0];
ConstRow row_1 = (*parent)[1];
ConstRow row_4 = (*parent)[4];
TableRef regular_0 = parent->get_subtable(0,0);
TableRef regular_1 = parent->get_subtable(0,1);
TableRef regular_4 = parent->get_subtable(0,4);
TableRef mixed_0 = parent->get_subtable(1,0);
TableRef mixed_1 = parent->get_subtable(1,1);
TableRef mixed_4 = parent->get_subtable(1,4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(4, row_4.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0,0));
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(14, regular_4->get_int(0,0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_4 && mixed_4->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0,0));
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(24, mixed_4->get_int(0,0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(2, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(14, regular_4->get_int(0,0));
CHECK_EQUAL(regular_1, parent->get_subtable(0,1));
CHECK_EQUAL(regular_4, parent->get_subtable(0,2));
CHECK(!mixed_0->is_attached());
CHECK(mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(24, mixed_4->get_int(0,0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1,1));
CHECK_EQUAL(mixed_4, parent->get_subtable(1,2));
// Perform two more 'move last over' operations which brings the number
// of rows down from 3 to 1
parent->move_last_over(1); // Move row at index 2 to index 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(14, regular_4->get_int(0,0));
CHECK_EQUAL(regular_4, parent->get_subtable(0,0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(24, mixed_4->get_int(0,0));
CHECK_EQUAL(mixed_4, parent->get_subtable(1,0));
}
// Use second table to check with accessors on row indexes 0, 2, and 3, but
// none at index 1 and 4.
{
TableRef parent = parent_2;
ConstRow row_0 = (*parent)[0];
ConstRow row_2 = (*parent)[2];
ConstRow row_3 = (*parent)[3];
TableRef regular_0 = parent->get_subtable(0,0);
TableRef regular_2 = parent->get_subtable(0,2);
TableRef regular_3 = parent->get_subtable(0,3);
TableRef mixed_0 = parent->get_subtable(1,0);
TableRef mixed_2 = parent->get_subtable(1,2);
TableRef mixed_3 = parent->get_subtable(1,3);
CHECK(row_0.is_attached());
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(2, row_2.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0,0));
CHECK_EQUAL(12, regular_2->get_int(0,0));
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_2 && mixed_2->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0,0));
CHECK_EQUAL(22, mixed_2->get_int(0,0));
CHECK_EQUAL(23, mixed_3->get_int(0,0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(!mixed_3->is_attached());
}
// Use third table to check with accessors on row indexes 1 and 3, but none
// at index 0, 2, and 4.
{
TableRef parent = parent_3;
ConstRow row_1 = (*parent)[1];
ConstRow row_3 = (*parent)[3];
TableRef regular_1 = parent->get_subtable(0,1);
TableRef regular_3 = parent->get_subtable(0,3);
TableRef mixed_1 = parent->get_subtable(1,1);
TableRef mixed_3 = parent->get_subtable(1,3);
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(23, mixed_3->get_int(0,0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(0, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0,0));
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_1, parent->get_subtable(0,1));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0,0));
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1,1));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0,0));
CHECK_EQUAL(regular_3, parent->get_subtable(0,0));
CHECK(!mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0,0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1,0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_1.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_1->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(!mixed_3->is_attached());
}
}
TEST(Table_EnumStringInsertEmptyRow)
{
Table table;
table.add_column(type_String, "");
table.add_empty_row(128);
for (int i = 0; i < 128; ++i)
table.set_string(0, i, "foo");
DescriptorRef desc = table.get_descriptor();
CHECK_EQUAL(0, desc->get_num_unique_values(0));
table.optimize();
// Make sure we now have an enumerated strings column
CHECK_EQUAL(1, desc->get_num_unique_values(0));
table.add_empty_row();
CHECK_EQUAL("", table.get_string(0, 128));
}
TEST(Table_AddColumnWithThreeLevelBptree)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE*REALM_MAX_BPNODE_SIZE+1);
table.add_column(type_Int, "");
table.verify();
}
TEST(Table_ClearWithTwoLevelBptree)
{
Table table;
table.add_column(type_Mixed, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE+1);
table.clear();
table.verify();
}
TEST(Table_IndexStringDelete)
{
Table t;
t.add_column(type_String, "str");
t.add_search_index(0);
std::ostringstream out;
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
out.str(std::string());
out << i;
t.set_string(0, i, out.str());
}
t.clear();
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
out.str(std::string());
out << i;
t.set_string(0, i, out.str());
}
}
#if REALM_NULL_STRINGS == 1
TEST(Table_Nulls)
{
// 'round' lets us run this entire test both with and without index and with/without optimize/enum
for (size_t round = 0; round < 5; round++) {
Table t;
TableView tv;
t.add_column(type_String, "str", true /*nullable*/ );
if (round == 1)
t.add_search_index(0);
else if (round == 2)
t.optimize(true);
else if (round == 3) {
t.add_search_index(0);
t.optimize(true);
}
else if (round == 4) {
t.optimize(true);
t.add_search_index(0);
}
t.add_empty_row(3);
t.set_string(0, 0, "foo"); // short strings
t.set_string(0, 1, "");
t.set_string(0, 2, realm::null());
CHECK_EQUAL(1, t.count_string(0, "foo"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "foo"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "foo");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYY"); // medium strings (< 64)
CHECK_EQUAL(1, t.count_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYY");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
// long strings (>= 64)
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, t.count_string(0,
"xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0,
"xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
}
{
Table t;
t.add_column(type_Int, "int", true); // nullable = true
t.add_column(type_Bool, "bool", true); // nullable = true
t.add_column(type_DateTime, "bool", true); // nullable = true
t.add_empty_row(2);
t.set_int(0, 0, 65);
t.set_bool(1, 0, false);
t.set_datetime(2, 0, DateTime(3));
CHECK_EQUAL(65, t.get_int(0, 0));
CHECK_EQUAL(false, t.get_bool(1, 0));
CHECK_EQUAL(DateTime(3), t.get_datetime(2, 0));
CHECK_EQUAL(65, t.maximum_int(0));
CHECK_EQUAL(65, t.minimum_int(0));
CHECK_EQUAL(DateTime(3), t.maximum_datetime(2));
CHECK_EQUAL(DateTime(3), t.minimum_datetime(2));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(!t.is_null(2, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK(t.is_null(2, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(1, t.find_first_null(2));
CHECK_EQUAL(not_found, t.find_first_int(0, -1));
CHECK_EQUAL(not_found, t.find_first_bool(1, true));
CHECK_EQUAL(not_found, t.find_first_datetime(2, DateTime(5)));
CHECK_EQUAL(0, t.find_first_int(0, 65));
CHECK_EQUAL(0, t.find_first_bool(1, false));
CHECK_EQUAL(0, t.find_first_datetime(2, DateTime(3)));
t.set_null(0, 0);
t.set_null(1, 0);
t.set_null(2, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
CHECK(t.is_null(2, 0));
}
{
Table t;
t.add_column(type_Float, "float", true); // nullable = true
t.add_column(type_Double, "double", true); // nullable = true
t.add_empty_row(2);
t.set_float(0, 0, 1.23f);
t.set_double(1, 0, 12.3);
CHECK_EQUAL(1.23f, t.get_float(0, 0));
CHECK_EQUAL(12.3, t.get_double(1, 0));
CHECK_EQUAL(1.23f, t.maximum_float(0));
CHECK_EQUAL(1.23f, t.minimum_float(0));
CHECK_EQUAL(12.3, t.maximum_double(1));
CHECK_EQUAL(12.3, t.minimum_double(1));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(not_found, t.find_first_float(0, 2.22f));
CHECK_EQUAL(not_found, t.find_first_double(1, 2.22));
CHECK_EQUAL(0, t.find_first_float(0, 1.23f));
CHECK_EQUAL(0, t.find_first_double(1, 12.3));
t.set_null(0, 0);
t.set_null(1, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
}
}
#endif
TEST(Table_RowAccessor_Null)
{
Table table;
size_t col_bool = table.add_column(type_Bool, "bool", true);
size_t col_int = table.add_column(type_Int, "int", true);
size_t col_string = table.add_column(type_String, "string", true);
size_t col_float = table.add_column(type_Float, "float", true);
size_t col_double = table.add_column(type_Double, "double", true);
size_t col_date = table.add_column(type_DateTime, "date", true);
size_t col_binary = table.add_column(type_Binary, "binary", true);
{
table.add_empty_row();
Row row = table[0];
row.set_null(col_bool);
row.set_null(col_int);
row.set_string(col_string, realm::null());
row.set_null(col_float);
row.set_null(col_double);
row.set_null(col_date);
row.set_binary(col_binary, BinaryData());
}
{
table.add_empty_row();
Row row = table[1];
row.set_bool(col_bool, true);
row.set_int(col_int, 1);
row.set_string(col_string, "1");
row.set_float(col_float, 1.0);
row.set_double(col_double, 1.0);
row.set_datetime(col_date, DateTime(1));
row.set_binary(col_binary, BinaryData("a"));
}
{
Row row = table[0];
CHECK(row.is_null(col_bool));
CHECK(row.is_null(col_int));
CHECK(row.is_null(col_string));
CHECK(row.is_null(col_float));
CHECK(row.is_null(col_double));
CHECK(row.is_null(col_date));
CHECK(row.is_null(col_binary));
}
{
Row row = table[1];
CHECK_EQUAL(true, row.get_bool(col_bool));
CHECK_EQUAL(1, row.get_int(col_int));
CHECK_EQUAL("1", row.get_string(col_string));
CHECK_EQUAL(1.0, row.get_float(col_float));
CHECK_EQUAL(1.0, row.get_double(col_double));
CHECK_EQUAL(DateTime(1), row.get_datetime(col_date));
CHECK_EQUAL(BinaryData("a"), row.get_binary(col_binary));
}
}
// This triggers a severe bug in the Array::alloc() allocator in which its capacity-doubling
// scheme forgets to test of the doubling has overflowed the maximum allowed size of an
// array which is 2^20 - 1 bytes
TEST(Table_AllocatorCapacityBug)
{
char* buf = new char[20000000];
// First a simple trigger of `Assertion failed: value <= 0xFFFFFL [26000016, 16777215]`
{
ref_type ref = BinaryColumn::create(Allocator::get_default());
BinaryColumn c(Allocator::get_default(), ref, true);
c.add(BinaryData(buf, 13000000));
c.set(0, BinaryData(buf, 14000000));
}
// Now a small fuzzy test to catch other such bugs
{
Table t;
t.add_column(type_Binary, "", true);
for (size_t j = 0; j < 100; j++) {
size_t r = (j * 123456789 + 123456789) % 100;
if (r < 20) {
t.add_empty_row();
}
else if (t.size() > 0 && t.size() < 5) {
// Set only if there are no more than 4 rows, else it takes up too much space on devices (4 * 16 MB
// worst case now)
size_t row = (j * 123456789 + 123456789) % t.size();
size_t len = (j * 123456789 + 123456789) % 16000000;
BinaryData bd;
bd = BinaryData(buf, len);
t.set_binary(0, row, bd);
}
else if (t.size() >= 4) {
t.clear();
}
}
}
delete buf;
}
#endif // TEST_TABLE
|
#include <gp_Pnt2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <BRepPrimAPI_MakeBox.hxx>
#include <BRepPrimAPI_MakePrism.hxx>
#include <BRepAlgoAPI_Fuse.hxx>
#include <BRepAlgoAPI_Cut.hxx>
#include <BRepAlgoAPI_Common.hxx>
#include <BRepAlgoAPI_Common.hxx>
#include <BRepBuilderAPI_MakeEdge2d.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeWire.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <StlAPI_Writer.hxx>
#include <Standard_Failure.hxx>
#include <rice/Class.hpp>
#include <rice/Exception.hpp>
#include <rice/Array.hpp>
using namespace Rice;
Data_Type<Standard_Failure> rb_cOCEError;
Class rb_cShape;
void translate_oce_exception(const Standard_Failure &e)
{
//Data_Object<Standard_Failure> e_obj(
// new Standard_Failure(e), rb_cOCEError);
throw Exception(rb_cOCEError, "%s", e.GetMessageString());
}
void shape_write_stl(Object self, String path)
{
Object shape_obj = self;
do {
shape_obj = shape_obj.call("render");
} while (shape_obj.is_a(rb_cShape));
if (shape_obj.is_nil()) {
throw Exception(rb_eArgError, "render returned nil");
}
Data_Object<TopoDS_Shape> shape(shape_obj);
StlAPI_Writer writer;
writer.ASCIIMode() = false;
writer.RelativeMode() = false;
writer.SetDeflection(0.05); // TODO: deflection param
writer.Write(*shape, path.c_str());
}
static gp_Pnt2d from_ruby_pnt2d(Object obj)
{
Array ary(obj);
if (ary.size() != 2) {
throw Exception(rb_eArgError,
"2D points must be arrays with 2 numbers each");
}
return gp_Pnt2d(
from_ruby<Standard_Real>(ary[0]),
from_ruby<Standard_Real>(ary[1]));
}
void polygon_initialize(Object self, Array points, Object paths)
{
self.iv_set("@points", points);
self.iv_set("@paths", paths);
if (paths.is_nil()) {
BRepBuilderAPI_MakeWire wire_maker;
for (size_t i = 0; i < points.size(); ++i) {
const size_t j = (i + 1) % points.size();
gp_Pnt2d gp_p1(from_ruby_pnt2d(points[i]));
gp_Pnt2d gp_p2(from_ruby_pnt2d(points[j]));
wire_maker.Add(
BRepBuilderAPI_MakeEdge2d(gp_p1, gp_p2).Edge());
}
self.iv_set("@shape",
BRepBuilderAPI_MakeFace(wire_maker.Wire()).Shape());
} else {
// TODO
}
}
void box_initialize(Object self, double xsize, double ysize, double zsize)
{
self.iv_set("@xsize", xsize);
self.iv_set("@ysize", ysize);
self.iv_set("@zsize", zsize);
self.iv_set("@shape",
BRepPrimAPI_MakeBox(xsize, ysize, zsize).Shape());
}
void combination_initialize(Object self, Object a, Object b)
{
self.iv_set("@a", a);
self.iv_set("@b", b);
}
Object union_render(Object self)
{
Data_Object<TopoDS_Shape> shape_a = self.iv_get("@a").call("render");
Data_Object<TopoDS_Shape> shape_b = self.iv_get("@b").call("render");
return to_ruby(
BRepAlgoAPI_Fuse(*shape_a, *shape_b).Shape());
}
Object difference_render(Object self)
{
Data_Object<TopoDS_Shape> shape_a = self.iv_get("@a").call("render");
Data_Object<TopoDS_Shape> shape_b = self.iv_get("@b").call("render");
return to_ruby(
BRepAlgoAPI_Cut(*shape_a, *shape_b).Shape());
}
Object intersection_render(Object self)
{
Data_Object<TopoDS_Shape> shape_a = self.iv_get("@a").call("render");
Data_Object<TopoDS_Shape> shape_b = self.iv_get("@b").call("render");
return to_ruby(
BRepAlgoAPI_Common(*shape_a, *shape_b).Shape());
}
// initialize is defined in Ruby code
void linear_extrusion_render(Object self)
{
Object profile = self.iv_get("@profile");
Standard_Real height = from_ruby<Standard_Real>(self.iv_get("@height"));
Standard_Real twist = from_ruby<Standard_Real>(self.iv_get("@twist"));
Data_Object<TopoDS_Shape> shape = profile.call("render");
if (0 == twist) {
self.iv_set("@shape",
BRepPrimAPI_MakePrism(*shape, gp_Vec(0, 0, height), true).Shape());
} else {
// TODO
}
}
extern "C"
void Init__rcad()
{
Data_Type<TopoDS_Shape> rb_cRenderedShape =
define_class<TopoDS_Shape>("RenderedShape");
Data_Type<Standard_Failure> rb_cOCEError =
define_class("rb_cOCEError", rb_eRuntimeError);
rb_cShape = define_class("Shape")
.add_handler<Standard_Failure>(translate_oce_exception)
.define_method("write_stl", &shape_write_stl);
Class rb_cPolygon = define_class("Polygon", rb_cShape)
.define_method("initialize", &polygon_initialize,
(Arg("points"), Arg("paths") = Object(Qnil)));
Class rb_cBox = define_class("Box", rb_cShape)
.define_method("initialize", &box_initialize);
Class rb_cCombination = define_class("Combination", rb_cShape)
.define_method("initialize", &combination_initialize);
Class rb_cUnion = define_class("Union", rb_cCombination)
.define_method("render", &union_render);
Class rb_cDifference = define_class("Difference", rb_cCombination)
.define_method("render", &difference_render);
Class rb_cIntersection = define_class("Intersection", rb_cCombination)
.define_method("render", &intersection_render);
Class rb_cLinearExtrusion = define_class("LinearExtrusion", rb_cShape)
.define_method("render", &linear_extrusion_render);
}
LinearExtrusion.render should return a shape, not set @shape.
#include <gp_Pnt2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <BRepPrimAPI_MakeBox.hxx>
#include <BRepPrimAPI_MakePrism.hxx>
#include <BRepAlgoAPI_Fuse.hxx>
#include <BRepAlgoAPI_Cut.hxx>
#include <BRepAlgoAPI_Common.hxx>
#include <BRepAlgoAPI_Common.hxx>
#include <BRepBuilderAPI_MakeEdge2d.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeWire.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <StlAPI_Writer.hxx>
#include <Standard_Failure.hxx>
#include <rice/Class.hpp>
#include <rice/Exception.hpp>
#include <rice/Array.hpp>
using namespace Rice;
Data_Type<Standard_Failure> rb_cOCEError;
Class rb_cShape;
void translate_oce_exception(const Standard_Failure &e)
{
//Data_Object<Standard_Failure> e_obj(
// new Standard_Failure(e), rb_cOCEError);
throw Exception(rb_cOCEError, "%s", e.GetMessageString());
}
void shape_write_stl(Object self, String path)
{
Object shape_obj = self;
do {
shape_obj = shape_obj.call("render");
} while (shape_obj.is_a(rb_cShape));
if (shape_obj.is_nil()) {
throw Exception(rb_eArgError, "render returned nil");
}
Data_Object<TopoDS_Shape> shape(shape_obj);
StlAPI_Writer writer;
writer.ASCIIMode() = false;
writer.RelativeMode() = false;
writer.SetDeflection(0.05); // TODO: deflection param
writer.Write(*shape, path.c_str());
}
static gp_Pnt2d from_ruby_pnt2d(Object obj)
{
Array ary(obj);
if (ary.size() != 2) {
throw Exception(rb_eArgError,
"2D points must be arrays with 2 numbers each");
}
return gp_Pnt2d(
from_ruby<Standard_Real>(ary[0]),
from_ruby<Standard_Real>(ary[1]));
}
void polygon_initialize(Object self, Array points, Object paths)
{
self.iv_set("@points", points);
self.iv_set("@paths", paths);
if (paths.is_nil()) {
BRepBuilderAPI_MakeWire wire_maker;
for (size_t i = 0; i < points.size(); ++i) {
const size_t j = (i + 1) % points.size();
gp_Pnt2d gp_p1(from_ruby_pnt2d(points[i]));
gp_Pnt2d gp_p2(from_ruby_pnt2d(points[j]));
wire_maker.Add(
BRepBuilderAPI_MakeEdge2d(gp_p1, gp_p2).Edge());
}
self.iv_set("@shape",
BRepBuilderAPI_MakeFace(wire_maker.Wire()).Shape());
} else {
// TODO
}
}
void box_initialize(Object self, double xsize, double ysize, double zsize)
{
self.iv_set("@xsize", xsize);
self.iv_set("@ysize", ysize);
self.iv_set("@zsize", zsize);
self.iv_set("@shape",
BRepPrimAPI_MakeBox(xsize, ysize, zsize).Shape());
}
void combination_initialize(Object self, Object a, Object b)
{
self.iv_set("@a", a);
self.iv_set("@b", b);
}
Object union_render(Object self)
{
Data_Object<TopoDS_Shape> shape_a = self.iv_get("@a").call("render");
Data_Object<TopoDS_Shape> shape_b = self.iv_get("@b").call("render");
return to_ruby(
BRepAlgoAPI_Fuse(*shape_a, *shape_b).Shape());
}
Object difference_render(Object self)
{
Data_Object<TopoDS_Shape> shape_a = self.iv_get("@a").call("render");
Data_Object<TopoDS_Shape> shape_b = self.iv_get("@b").call("render");
return to_ruby(
BRepAlgoAPI_Cut(*shape_a, *shape_b).Shape());
}
Object intersection_render(Object self)
{
Data_Object<TopoDS_Shape> shape_a = self.iv_get("@a").call("render");
Data_Object<TopoDS_Shape> shape_b = self.iv_get("@b").call("render");
return to_ruby(
BRepAlgoAPI_Common(*shape_a, *shape_b).Shape());
}
// initialize is defined in Ruby code
Object linear_extrusion_render(Object self)
{
Object profile = self.iv_get("@profile");
Standard_Real height = from_ruby<Standard_Real>(self.iv_get("@height"));
Standard_Real twist = from_ruby<Standard_Real>(self.iv_get("@twist"));
Data_Object<TopoDS_Shape> shape = profile.call("render");
if (0 == twist) {
return to_ruby(
BRepPrimAPI_MakePrism(*shape, gp_Vec(0, 0, height), true).Shape());
} else {
// TODO
}
return Object();
}
extern "C"
void Init__rcad()
{
Data_Type<TopoDS_Shape> rb_cRenderedShape =
define_class<TopoDS_Shape>("RenderedShape");
Data_Type<Standard_Failure> rb_cOCEError =
define_class("rb_cOCEError", rb_eRuntimeError);
rb_cShape = define_class("Shape")
.add_handler<Standard_Failure>(translate_oce_exception)
.define_method("write_stl", &shape_write_stl);
Class rb_cPolygon = define_class("Polygon", rb_cShape)
.define_method("initialize", &polygon_initialize,
(Arg("points"), Arg("paths") = Object(Qnil)));
Class rb_cBox = define_class("Box", rb_cShape)
.define_method("initialize", &box_initialize);
Class rb_cCombination = define_class("Combination", rb_cShape)
.define_method("initialize", &combination_initialize);
Class rb_cUnion = define_class("Union", rb_cCombination)
.define_method("render", &union_render);
Class rb_cDifference = define_class("Difference", rb_cCombination)
.define_method("render", &difference_render);
Class rb_cIntersection = define_class("Intersection", rb_cCombination)
.define_method("render", &intersection_render);
Class rb_cLinearExtrusion = define_class("LinearExtrusion", rb_cShape)
.define_method("render", &linear_extrusion_render);
}
|
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "common_runtime_test.h"
#include "mirror/art_field-inl.h"
#include "mirror/art_method-inl.h"
#include "mirror/class-inl.h"
#include "mirror/string-inl.h"
#include <cstdio>
namespace art {
class StubTest : public CommonRuntimeTest {
protected:
// We need callee-save methods set up in the Runtime for exceptions.
void SetUp() OVERRIDE {
// Do the normal setup.
CommonRuntimeTest::SetUp();
{
// Create callee-save methods
ScopedObjectAccess soa(Thread::Current());
runtime_->SetInstructionSet(kRuntimeISA);
for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i);
if (!runtime_->HasCalleeSaveMethod(type)) {
runtime_->SetCalleeSaveMethod(runtime_->CreateCalleeSaveMethod(type), type);
}
}
}
}
void SetUpRuntimeOptions(Runtime::Options *options) OVERRIDE {
// Use a smaller heap
for (std::pair<std::string, const void*>& pair : *options) {
if (pair.first.find("-Xmx") == 0) {
pair.first = "-Xmx4M"; // Smallest we can go.
}
}
options->push_back(std::make_pair("-Xint", nullptr));
}
// Helper function needed since TEST_F makes a new class.
Thread::tls_ptr_sized_values* GetTlsPtr(Thread* self) {
return &self->tlsPtr_;
}
public:
size_t Invoke3(size_t arg0, size_t arg1, size_t arg2, uintptr_t code, Thread* self) {
return Invoke3WithReferrer(arg0, arg1, arg2, code, self, nullptr);
}
// TODO: Set up a frame according to referrer's specs.
size_t Invoke3WithReferrer(size_t arg0, size_t arg1, size_t arg2, uintptr_t code, Thread* self,
mirror::ArtMethod* referrer) {
// Push a transition back into managed code onto the linked list in thread.
ManagedStack fragment;
self->PushManagedStackFragment(&fragment);
size_t result;
size_t fpr_result = 0;
#if defined(__i386__)
// TODO: Set the thread?
__asm__ __volatile__(
"subl $12, %%esp\n\t" // Align stack.
"pushl %[referrer]\n\t" // Store referrer.
"call *%%edi\n\t" // Call the stub
"addl $16, %%esp" // Pop referrer
: "=a" (result)
// Use the result from eax
: "a"(arg0), "c"(arg1), "d"(arg2), "D"(code), [referrer]"r"(referrer)
// This places code into edi, arg0 into eax, arg1 into ecx, and arg2 into edx
: "memory"); // clobber.
// TODO: Should we clobber the other registers? EBX gets clobbered by some of the stubs,
// but compilation fails when declaring that.
#elif defined(__arm__)
__asm__ __volatile__(
"push {r1-r12, lr}\n\t" // Save state, 13*4B = 52B
".cfi_adjust_cfa_offset 52\n\t"
"push {r9}\n\t"
".cfi_adjust_cfa_offset 4\n\t"
"mov r9, %[referrer]\n\n"
"str r9, [sp, #-8]!\n\t" // Push referrer, +8B padding so 16B aligned
".cfi_adjust_cfa_offset 8\n\t"
"ldr r9, [sp, #8]\n\t"
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #20\n\t"
"str %[arg0], [sp]\n\t"
"str %[arg1], [sp, #4]\n\t"
"str %[arg2], [sp, #8]\n\t"
"str %[code], [sp, #12]\n\t"
"str %[self], [sp, #16]\n\t"
"ldr r0, [sp]\n\t"
"ldr r1, [sp, #4]\n\t"
"ldr r2, [sp, #8]\n\t"
"ldr r3, [sp, #12]\n\t"
"ldr r9, [sp, #16]\n\t"
"add sp, sp, #20\n\t"
"blx r3\n\t" // Call the stub
"add sp, sp, #12\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -12\n\t"
"pop {r1-r12, lr}\n\t" // Restore state
".cfi_adjust_cfa_offset -52\n\t"
"mov %[result], r0\n\t" // Save the result
: [result] "=r" (result)
// Use the result from r0
: [arg0] "r"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer)
: "memory"); // clobber.
#elif defined(__aarch64__)
__asm__ __volatile__(
// Spill x0-x7 which we say we don't clobber. May contain args.
"sub sp, sp, #64\n\t"
".cfi_adjust_cfa_offset 64\n\t"
"stp x0, x1, [sp]\n\t"
"stp x2, x3, [sp, #16]\n\t"
"stp x4, x5, [sp, #32]\n\t"
"stp x6, x7, [sp, #48]\n\t"
"sub sp, sp, #16\n\t" // Reserve stack space, 16B aligned
".cfi_adjust_cfa_offset 16\n\t"
"str %[referrer], [sp]\n\t" // referrer
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #48\n\t"
".cfi_adjust_cfa_offset 48\n\t"
// All things are "r" constraints, so direct str/stp should work.
"stp %[arg0], %[arg1], [sp]\n\t"
"stp %[arg2], %[code], [sp, #16]\n\t"
"str %[self], [sp, #32]\n\t"
// Now we definitely have x0-x3 free, use it to garble d8 - d15
"movk x0, #0xfad0\n\t"
"movk x0, #0xebad, lsl #16\n\t"
"movk x0, #0xfad0, lsl #32\n\t"
"movk x0, #0xebad, lsl #48\n\t"
"fmov d8, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d9, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d10, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d11, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d12, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d13, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d14, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d15, x0\n\t"
// Load call params into the right registers.
"ldp x0, x1, [sp]\n\t"
"ldp x2, x3, [sp, #16]\n\t"
"ldr x18, [sp, #32]\n\t"
"add sp, sp, #48\n\t"
".cfi_adjust_cfa_offset -48\n\t"
"blr x3\n\t" // Call the stub
"mov x8, x0\n\t" // Store result
"add sp, sp, #16\n\t" // Drop the quick "frame"
".cfi_adjust_cfa_offset -16\n\t"
// Test d8 - d15. We can use x1 and x2.
"movk x1, #0xfad0\n\t"
"movk x1, #0xebad, lsl #16\n\t"
"movk x1, #0xfad0, lsl #32\n\t"
"movk x1, #0xebad, lsl #48\n\t"
"fmov x2, d8\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d9\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d10\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d11\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d12\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d13\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d14\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d15\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"mov x9, #0\n\t" // Use x9 as flag, in clobber list
// Finish up.
"2:\n\t"
"ldp x0, x1, [sp]\n\t" // Restore stuff not named clobbered, may contain fpr_result
"ldp x2, x3, [sp, #16]\n\t"
"ldp x4, x5, [sp, #32]\n\t"
"ldp x6, x7, [sp, #48]\n\t"
"add sp, sp, #64\n\t" // Free stack space, now sp as on entry
".cfi_adjust_cfa_offset -64\n\t"
"str x9, %[fpr_result]\n\t" // Store the FPR comparison result
"mov %[result], x8\n\t" // Store the call result
"b 3f\n\t" // Goto end
// Failed fpr verification.
"1:\n\t"
"mov x9, #1\n\t"
"b 2b\n\t" // Goto finish-up
// End
"3:\n\t"
: [result] "=r" (result)
// Use the result from r0
: [arg0] "0"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer), [fpr_result] "m" (fpr_result)
: "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20",
"x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x30",
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
"d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
"d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
"memory"); // clobber.
#elif defined(__x86_64__)
// Note: Uses the native convention
// TODO: Set the thread?
__asm__ __volatile__(
"pushq %[referrer]\n\t" // Push referrer
"pushq (%%rsp)\n\t" // & 16B alignment padding
".cfi_adjust_cfa_offset 16\n\t"
"call *%%rax\n\t" // Call the stub
"addq $16, %%rsp\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -16\n\t"
: "=a" (result)
// Use the result from rax
: "D"(arg0), "S"(arg1), "d"(arg2), "a"(code), [referrer] "m"(referrer)
// This places arg0 into rdi, arg1 into rsi, arg2 into rdx, and code into rax
: "rbx", "rcx", "rbp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"memory"); // clobber all
// TODO: Should we clobber the other registers?
#else
LOG(WARNING) << "Was asked to invoke for an architecture I do not understand.";
result = 0;
#endif
// Pop transition.
self->PopManagedStackFragment(fragment);
fp_result = fpr_result;
EXPECT_EQ(0U, fp_result);
return result;
}
// TODO: Set up a frame according to referrer's specs.
size_t Invoke3WithReferrerAndHidden(size_t arg0, size_t arg1, size_t arg2, uintptr_t code,
Thread* self, mirror::ArtMethod* referrer, size_t hidden) {
// Push a transition back into managed code onto the linked list in thread.
ManagedStack fragment;
self->PushManagedStackFragment(&fragment);
size_t result;
size_t fpr_result = 0;
#if defined(__i386__)
// TODO: Set the thread?
__asm__ __volatile__(
"movd %[hidden], %%xmm0\n\t"
"subl $12, %%esp\n\t" // Align stack.
"pushl %[referrer]\n\t" // Store referrer
"call *%%edi\n\t" // Call the stub
"addl $16, %%esp" // Pop referrer
: "=a" (result)
// Use the result from eax
: "a"(arg0), "c"(arg1), "d"(arg2), "D"(code), [referrer]"m"(referrer), [hidden]"r"(hidden)
// This places code into edi, arg0 into eax, arg1 into ecx, and arg2 into edx
: "memory"); // clobber.
// TODO: Should we clobber the other registers? EBX gets clobbered by some of the stubs,
// but compilation fails when declaring that.
#elif defined(__arm__)
__asm__ __volatile__(
"push {r1-r12, lr}\n\t" // Save state, 13*4B = 52B
".cfi_adjust_cfa_offset 52\n\t"
"push {r9}\n\t"
".cfi_adjust_cfa_offset 4\n\t"
"mov r9, %[referrer]\n\n"
"str r9, [sp, #-8]!\n\t" // Push referrer, +8B padding so 16B aligned
".cfi_adjust_cfa_offset 8\n\t"
"ldr r9, [sp, #8]\n\t"
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #24\n\t"
"str %[arg0], [sp]\n\t"
"str %[arg1], [sp, #4]\n\t"
"str %[arg2], [sp, #8]\n\t"
"str %[code], [sp, #12]\n\t"
"str %[self], [sp, #16]\n\t"
"str %[hidden], [sp, #20]\n\t"
"ldr r0, [sp]\n\t"
"ldr r1, [sp, #4]\n\t"
"ldr r2, [sp, #8]\n\t"
"ldr r3, [sp, #12]\n\t"
"ldr r9, [sp, #16]\n\t"
"ldr r12, [sp, #20]\n\t"
"add sp, sp, #24\n\t"
"blx r3\n\t" // Call the stub
"add sp, sp, #12\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -12\n\t"
"pop {r1-r12, lr}\n\t" // Restore state
".cfi_adjust_cfa_offset -52\n\t"
"mov %[result], r0\n\t" // Save the result
: [result] "=r" (result)
// Use the result from r0
: [arg0] "r"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer), [hidden] "r"(hidden)
: "memory"); // clobber.
#elif defined(__aarch64__)
__asm__ __volatile__(
// Spill x0-x7 which we say we don't clobber. May contain args.
"sub sp, sp, #64\n\t"
".cfi_adjust_cfa_offset 64\n\t"
"stp x0, x1, [sp]\n\t"
"stp x2, x3, [sp, #16]\n\t"
"stp x4, x5, [sp, #32]\n\t"
"stp x6, x7, [sp, #48]\n\t"
"sub sp, sp, #16\n\t" // Reserve stack space, 16B aligned
".cfi_adjust_cfa_offset 16\n\t"
"str %[referrer], [sp]\n\t" // referrer
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #48\n\t"
".cfi_adjust_cfa_offset 48\n\t"
// All things are "r" constraints, so direct str/stp should work.
"stp %[arg0], %[arg1], [sp]\n\t"
"stp %[arg2], %[code], [sp, #16]\n\t"
"stp %[self], %[hidden], [sp, #32]\n\t"
// Now we definitely have x0-x3 free, use it to garble d8 - d15
"movk x0, #0xfad0\n\t"
"movk x0, #0xebad, lsl #16\n\t"
"movk x0, #0xfad0, lsl #32\n\t"
"movk x0, #0xebad, lsl #48\n\t"
"fmov d8, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d9, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d10, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d11, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d12, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d13, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d14, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d15, x0\n\t"
// Load call params into the right registers.
"ldp x0, x1, [sp]\n\t"
"ldp x2, x3, [sp, #16]\n\t"
"ldp x18, x12, [sp, #32]\n\t"
"add sp, sp, #48\n\t"
".cfi_adjust_cfa_offset -48\n\t"
"blr x3\n\t" // Call the stub
"mov x8, x0\n\t" // Store result
"add sp, sp, #16\n\t" // Drop the quick "frame"
".cfi_adjust_cfa_offset -16\n\t"
// Test d8 - d15. We can use x1 and x2.
"movk x1, #0xfad0\n\t"
"movk x1, #0xebad, lsl #16\n\t"
"movk x1, #0xfad0, lsl #32\n\t"
"movk x1, #0xebad, lsl #48\n\t"
"fmov x2, d8\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d9\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d10\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d11\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d12\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d13\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d14\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d15\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"mov x9, #0\n\t" // Use x9 as flag, in clobber list
// Finish up.
"2:\n\t"
"ldp x0, x1, [sp]\n\t" // Restore stuff not named clobbered, may contain fpr_result
"ldp x2, x3, [sp, #16]\n\t"
"ldp x4, x5, [sp, #32]\n\t"
"ldp x6, x7, [sp, #48]\n\t"
"add sp, sp, #64\n\t" // Free stack space, now sp as on entry
".cfi_adjust_cfa_offset -64\n\t"
"str x9, %[fpr_result]\n\t" // Store the FPR comparison result
"mov %[result], x8\n\t" // Store the call result
"b 3f\n\t" // Goto end
// Failed fpr verification.
"1:\n\t"
"mov x9, #1\n\t"
"b 2b\n\t" // Goto finish-up
// End
"3:\n\t"
: [result] "=r" (result)
// Use the result from r0
: [arg0] "0"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer), [hidden] "r"(hidden), [fpr_result] "m" (fpr_result)
: "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20",
"x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x30",
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
"d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
"d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
"memory"); // clobber.
#elif defined(__x86_64__)
// Note: Uses the native convention
// TODO: Set the thread?
__asm__ __volatile__(
"movq %[hidden], %%r9\n\t" // No need to save r9, listed as clobbered
"movd %%r9, %%xmm0\n\t"
"pushq %[referrer]\n\t" // Push referrer
"pushq (%%rsp)\n\t" // & 16B alignment padding
".cfi_adjust_cfa_offset 16\n\t"
"call *%%rax\n\t" // Call the stub
"addq $16, %%rsp\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -16\n\t"
: "=a" (result)
// Use the result from rax
: "D"(arg0), "S"(arg1), "d"(arg2), "a"(code), [referrer] "m"(referrer), [hidden] "m"(hidden)
// This places arg0 into rdi, arg1 into rsi, arg2 into rdx, and code into rax
: "rbx", "rcx", "rbp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"memory"); // clobber all
// TODO: Should we clobber the other registers?
#else
LOG(WARNING) << "Was asked to invoke for an architecture I do not understand.";
result = 0;
#endif
// Pop transition.
self->PopManagedStackFragment(fragment);
fp_result = fpr_result;
EXPECT_EQ(0U, fp_result);
return result;
}
// Method with 32b arg0, 64b arg1
size_t Invoke3UWithReferrer(size_t arg0, uint64_t arg1, uintptr_t code, Thread* self,
mirror::ArtMethod* referrer) {
#if defined(__x86_64__) || defined(__aarch64__)
// Just pass through.
return Invoke3WithReferrer(arg0, arg1, 0U, code, self, referrer);
#else
// Need to split up arguments.
uint32_t lower = static_cast<uint32_t>(arg1 & 0xFFFFFFFF);
uint32_t upper = static_cast<uint32_t>((arg1 >> 32) & 0xFFFFFFFF);
return Invoke3WithReferrer(arg0, lower, upper, code, self, referrer);
#endif
}
// Method with 32b arg0, 32b arg1, 64b arg2
size_t Invoke3UUWithReferrer(uint32_t arg0, uint32_t arg1, uint64_t arg2, uintptr_t code,
Thread* self, mirror::ArtMethod* referrer) {
#if defined(__x86_64__) || defined(__aarch64__)
// Just pass through.
return Invoke3WithReferrer(arg0, arg1, arg2, code, self, referrer);
#else
// TODO: Needs 4-param invoke.
return 0;
#endif
}
protected:
size_t fp_result;
};
#if defined(__i386__) || defined(__x86_64__)
extern "C" void art_quick_memcpy(void);
#endif
TEST_F(StubTest, Memcpy) {
#if defined(__i386__) || defined(__x86_64__)
Thread* self = Thread::Current();
uint32_t orig[20];
uint32_t trg[20];
for (size_t i = 0; i < 20; ++i) {
orig[i] = i;
trg[i] = 0;
}
Invoke3(reinterpret_cast<size_t>(&trg[4]), reinterpret_cast<size_t>(&orig[4]),
10 * sizeof(uint32_t), reinterpret_cast<uintptr_t>(&art_quick_memcpy), self);
EXPECT_EQ(orig[0], trg[0]);
for (size_t i = 1; i < 4; ++i) {
EXPECT_NE(orig[i], trg[i]);
}
for (size_t i = 4; i < 14; ++i) {
EXPECT_EQ(orig[i], trg[i]);
}
for (size_t i = 14; i < 20; ++i) {
EXPECT_NE(orig[i], trg[i]);
}
// TODO: Test overlapping?
#else
LOG(INFO) << "Skipping memcpy as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping memcpy as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_lock_object(void);
#endif
TEST_F(StubTest, LockObject) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
static constexpr size_t kThinLockLoops = 100;
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(soa.Self());
Handle<mirror::String> obj(
hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
LockWord lock = obj->GetLockWord(false);
LockWord::LockState old_state = lock.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, old_state);
Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
LockWord lock_after = obj->GetLockWord(false);
LockWord::LockState new_state = lock_after.GetState();
EXPECT_EQ(LockWord::LockState::kThinLocked, new_state);
EXPECT_EQ(lock_after.ThinLockCount(), 0U); // Thin lock starts count at zero
for (size_t i = 1; i < kThinLockLoops; ++i) {
Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
// Check we're at lock count i
LockWord l_inc = obj->GetLockWord(false);
LockWord::LockState l_inc_state = l_inc.GetState();
EXPECT_EQ(LockWord::LockState::kThinLocked, l_inc_state);
EXPECT_EQ(l_inc.ThinLockCount(), i);
}
// Force a fat lock by running identity hashcode to fill up lock word.
Handle<mirror::String> obj2(hs.NewHandle(
mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
obj2->IdentityHashCode();
Invoke3(reinterpret_cast<size_t>(obj2.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
LockWord lock_after2 = obj2->GetLockWord(false);
LockWord::LockState new_state2 = lock_after2.GetState();
EXPECT_EQ(LockWord::LockState::kFatLocked, new_state2);
EXPECT_NE(lock_after2.FatLockMonitor(), static_cast<Monitor*>(nullptr));
// Test done.
#else
LOG(INFO) << "Skipping lock_object as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping lock_object as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
class RandGen {
public:
explicit RandGen(uint32_t seed) : val_(seed) {}
uint32_t next() {
val_ = val_ * 48271 % 2147483647 + 13;
return val_;
}
uint32_t val_;
};
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_lock_object(void);
extern "C" void art_quick_unlock_object(void);
#endif
// NO_THREAD_SAFETY_ANALYSIS as we do not want to grab exclusive mutator lock for MonitorInfo.
static void TestUnlockObject(StubTest* test) NO_THREAD_SAFETY_ANALYSIS {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
static constexpr size_t kThinLockLoops = 100;
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
static constexpr size_t kNumberOfLocks = 10; // Number of objects = lock
StackHandleScope<kNumberOfLocks + 1> hs(self);
Handle<mirror::String> obj(
hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
LockWord lock = obj->GetLockWord(false);
LockWord::LockState old_state = lock.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, old_state);
test->Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
// This should be an illegal monitor state.
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
LockWord lock_after = obj->GetLockWord(false);
LockWord::LockState new_state = lock_after.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, new_state);
test->Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
LockWord lock_after2 = obj->GetLockWord(false);
LockWord::LockState new_state2 = lock_after2.GetState();
EXPECT_EQ(LockWord::LockState::kThinLocked, new_state2);
test->Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
LockWord lock_after3 = obj->GetLockWord(false);
LockWord::LockState new_state3 = lock_after3.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, new_state3);
// Stress test:
// Keep a number of objects and their locks in flight. Randomly lock or unlock one of them in
// each step.
RandGen r(0x1234);
constexpr size_t kIterations = 10000; // Number of iterations
constexpr size_t kMoveToFat = 1000; // Chance of 1:kMoveFat to make a lock fat.
size_t counts[kNumberOfLocks];
bool fat[kNumberOfLocks]; // Whether a lock should be thin or fat.
Handle<mirror::String> objects[kNumberOfLocks];
// Initialize = allocate.
for (size_t i = 0; i < kNumberOfLocks; ++i) {
counts[i] = 0;
fat[i] = false;
objects[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), ""));
}
for (size_t i = 0; i < kIterations; ++i) {
// Select which lock to update.
size_t index = r.next() % kNumberOfLocks;
// Make lock fat?
if (!fat[index] && (r.next() % kMoveToFat == 0)) {
fat[index] = true;
objects[index]->IdentityHashCode();
LockWord lock_iter = objects[index]->GetLockWord(false);
LockWord::LockState iter_state = lock_iter.GetState();
if (counts[index] == 0) {
EXPECT_EQ(LockWord::LockState::kHashCode, iter_state);
} else {
EXPECT_EQ(LockWord::LockState::kFatLocked, iter_state);
}
} else {
bool lock; // Whether to lock or unlock in this step.
if (counts[index] == 0) {
lock = true;
} else if (counts[index] == kThinLockLoops) {
lock = false;
} else {
// Randomly.
lock = r.next() % 2 == 0;
}
if (lock) {
test->Invoke3(reinterpret_cast<size_t>(objects[index].Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
counts[index]++;
} else {
test->Invoke3(reinterpret_cast<size_t>(objects[index].Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
counts[index]--;
}
EXPECT_FALSE(self->IsExceptionPending());
// Check the new state.
LockWord lock_iter = objects[index]->GetLockWord(true);
LockWord::LockState iter_state = lock_iter.GetState();
if (fat[index]) {
// Abuse MonitorInfo.
EXPECT_EQ(LockWord::LockState::kFatLocked, iter_state) << index;
MonitorInfo info(objects[index].Get());
EXPECT_EQ(counts[index], info.entry_count_) << index;
} else {
if (counts[index] > 0) {
EXPECT_EQ(LockWord::LockState::kThinLocked, iter_state);
EXPECT_EQ(counts[index] - 1, lock_iter.ThinLockCount());
} else {
EXPECT_EQ(LockWord::LockState::kUnlocked, iter_state);
}
}
}
}
// Unlock the remaining count times and then check it's unlocked. Then deallocate.
// Go reverse order to correctly handle Handles.
for (size_t i = 0; i < kNumberOfLocks; ++i) {
size_t index = kNumberOfLocks - 1 - i;
size_t count = counts[index];
while (count > 0) {
test->Invoke3(reinterpret_cast<size_t>(objects[index].Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
count--;
}
LockWord lock_after4 = objects[index]->GetLockWord(false);
LockWord::LockState new_state4 = lock_after4.GetState();
EXPECT_TRUE(LockWord::LockState::kUnlocked == new_state4
|| LockWord::LockState::kFatLocked == new_state4);
}
// Test done.
#else
LOG(INFO) << "Skipping unlock_object as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping unlock_object as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
TEST_F(StubTest, UnlockObject) {
TestUnlockObject(this);
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_check_cast(void);
#endif
TEST_F(StubTest, CheckCast) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
Thread* self = Thread::Current();
// Find some classes.
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(soa.Self());
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
Handle<mirror::Class> c2(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;")));
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(c.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(c2.Get()), reinterpret_cast<size_t>(c2.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(c2.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_FALSE(self->IsExceptionPending());
// TODO: Make the following work. But that would require correct managed frames.
Invoke3(reinterpret_cast<size_t>(c2.Get()), reinterpret_cast<size_t>(c.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
#else
LOG(INFO) << "Skipping check_cast as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping check_cast as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_aput_obj_with_null_and_bound_check(void);
// Do not check non-checked ones, we'd need handlers and stuff...
#endif
TEST_F(StubTest, APutObj) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<5> hs(soa.Self());
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
Handle<mirror::Class> ca(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;")));
// Build a string array of size 1
Handle<mirror::ObjectArray<mirror::Object>> array(
hs.NewHandle(mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), ca.Get(), 10)));
// Build a string -> should be assignable
Handle<mirror::String> str_obj(
hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
// Build a generic object -> should fail assigning
Handle<mirror::Object> obj_obj(hs.NewHandle(c->AllocObject(soa.Self())));
// Play with it...
// 1) Success cases
// 1.1) Assign str_obj to array[0..3]
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(array.Get()), 0U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(0));
Invoke3(reinterpret_cast<size_t>(array.Get()), 1U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(1));
Invoke3(reinterpret_cast<size_t>(array.Get()), 2U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(2));
Invoke3(reinterpret_cast<size_t>(array.Get()), 3U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(3));
// 1.2) Assign null to array[0..3]
Invoke3(reinterpret_cast<size_t>(array.Get()), 0U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(0));
Invoke3(reinterpret_cast<size_t>(array.Get()), 1U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(1));
Invoke3(reinterpret_cast<size_t>(array.Get()), 2U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(2));
Invoke3(reinterpret_cast<size_t>(array.Get()), 3U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(3));
// TODO: Check _which_ exception is thrown. Then make 3) check that it's the right check order.
// 2) Failure cases (str into str[])
// 2.1) Array = null
// TODO: Throwing NPE needs actual DEX code
// Invoke3(reinterpret_cast<size_t>(nullptr), 0U, reinterpret_cast<size_t>(str_obj.Get()),
// reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
//
// EXPECT_TRUE(self->IsExceptionPending());
// self->ClearException();
// 2.2) Index < 0
Invoke3(reinterpret_cast<size_t>(array.Get()), static_cast<size_t>(-1),
reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
// 2.3) Index > 0
Invoke3(reinterpret_cast<size_t>(array.Get()), 10U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
// 3) Failure cases (obj into str[])
Invoke3(reinterpret_cast<size_t>(array.Get()), 0U, reinterpret_cast<size_t>(obj_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
// Tests done.
#else
LOG(INFO) << "Skipping aput_obj as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping aput_obj as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
TEST_F(StubTest, AllocObject) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
// TODO: Check the "Unresolved" allocation stubs
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(soa.Self());
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
// Play with it...
EXPECT_FALSE(self->IsExceptionPending());
{
// Use an arbitrary method from c to use as referrer
size_t result = Invoke3(static_cast<size_t>(c->GetDexTypeIndex()), // type_idx
reinterpret_cast<size_t>(c->GetVirtualMethod(0)), // arbitrary
0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObject),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
}
{
// We can use nullptr in the second argument as we do not need a method here (not used in
// resolved/initialized cases)
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObjectResolved),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
}
{
// We can use nullptr in the second argument as we do not need a method here (not used in
// resolved/initialized cases)
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObjectInitialized),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
}
// Failure tests.
// Out-of-memory.
{
Runtime::Current()->GetHeap()->SetIdealFootprint(1 * GB);
// Array helps to fill memory faster.
Handle<mirror::Class> ca(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
// Use arbitrary large amount for now.
static const size_t kMaxHandles = 1000000;
std::unique_ptr<StackHandleScope<kMaxHandles>> hsp(new StackHandleScope<kMaxHandles>(self));
std::vector<Handle<mirror::Object>> handles;
// Start allocating with 128K
size_t length = 128 * KB / 4;
while (length > 10) {
Handle<mirror::Object> h(hsp->NewHandle<mirror::Object>(
mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), ca.Get(), length / 4)));
if (self->IsExceptionPending() || h.Get() == nullptr) {
self->ClearException();
// Try a smaller length
length = length / 8;
// Use at most half the reported free space.
size_t mem = Runtime::Current()->GetHeap()->GetFreeMemory();
if (length * 8 > mem) {
length = mem / 8;
}
} else {
handles.push_back(h);
}
}
LOG(INFO) << "Used " << handles.size() << " arrays to fill space.";
// Allocate simple objects till it fails.
while (!self->IsExceptionPending()) {
Handle<mirror::Object> h = hsp->NewHandle(c->AllocObject(soa.Self()));
if (!self->IsExceptionPending() && h.Get() != nullptr) {
handles.push_back(h);
}
}
self->ClearException();
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObjectInitialized),
self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
EXPECT_EQ(reinterpret_cast<size_t>(nullptr), result);
}
// Tests done.
#else
LOG(INFO) << "Skipping alloc_object as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping alloc_object as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
TEST_F(StubTest, AllocObjectArray) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
// TODO: Check the "Unresolved" allocation stubs
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(self);
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
// Needed to have a linked method.
Handle<mirror::Class> c_obj(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
// Play with it...
EXPECT_FALSE(self->IsExceptionPending());
// For some reason this does not work, as the type_idx is artificial and outside what the
// resolved types of c_obj allow...
if (false) {
// Use an arbitrary method from c to use as referrer
size_t result = Invoke3(static_cast<size_t>(c->GetDexTypeIndex()), // type_idx
reinterpret_cast<size_t>(c_obj->GetVirtualMethod(0)), // arbitrary
10U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocArray),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Array* obj = reinterpret_cast<mirror::Array*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
EXPECT_EQ(obj->GetLength(), 10);
}
{
// We can use nullptr in the second argument as we do not need a method here (not used in
// resolved/initialized cases)
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 10U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocArrayResolved),
self);
EXPECT_FALSE(self->IsExceptionPending()) << PrettyTypeOf(self->GetException(nullptr));
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_TRUE(obj->IsArrayInstance());
EXPECT_TRUE(obj->IsObjectArray());
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
mirror::Array* array = reinterpret_cast<mirror::Array*>(result);
EXPECT_EQ(array->GetLength(), 10);
}
// Failure tests.
// Out-of-memory.
{
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr),
GB, // that should fail...
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocArrayResolved),
self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
EXPECT_EQ(reinterpret_cast<size_t>(nullptr), result);
}
// Tests done.
#else
LOG(INFO) << "Skipping alloc_array as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping alloc_array as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_string_compareto(void);
#endif
TEST_F(StubTest, StringCompareTo) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
// TODO: Check the "Unresolved" allocation stubs
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
// Create some strings
// Use array so we can index into it and use a matrix for expected results
// Setup: The first half is standard. The second half uses a non-zero offset.
// TODO: Shared backing arrays.
static constexpr size_t kBaseStringCount = 7;
const char* c[kBaseStringCount] = { "", "", "a", "aa", "ab", "aac", "aac" , };
static constexpr size_t kStringCount = 2 * kBaseStringCount;
StackHandleScope<kStringCount> hs(self);
Handle<mirror::String> s[kStringCount];
for (size_t i = 0; i < kBaseStringCount; ++i) {
s[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), c[i]));
}
RandGen r(0x1234);
for (size_t i = kBaseStringCount; i < kStringCount; ++i) {
s[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), c[i - kBaseStringCount]));
int32_t length = s[i]->GetLength();
if (length > 1) {
// Set a random offset and length.
int32_t new_offset = 1 + (r.next() % (length - 1));
int32_t rest = length - new_offset - 1;
int32_t new_length = 1 + (rest > 0 ? r.next() % rest : 0);
s[i]->SetField32<false>(mirror::String::CountOffset(), new_length);
s[i]->SetField32<false>(mirror::String::OffsetOffset(), new_offset);
}
}
// TODO: wide characters
// Matrix of expectations. First component is first parameter. Note we only check against the
// sign, not the value. As we are testing random offsets, we need to compute this and need to
// rely on String::CompareTo being correct.
int32_t expected[kStringCount][kStringCount];
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kStringCount; ++y) {
expected[x][y] = s[x]->CompareTo(s[y].Get());
}
}
// Play with it...
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kStringCount; ++y) {
// Test string_compareto x y
size_t result = Invoke3(reinterpret_cast<size_t>(s[x].Get()),
reinterpret_cast<size_t>(s[y].Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_string_compareto), self);
EXPECT_FALSE(self->IsExceptionPending());
// The result is a 32b signed integer
union {
size_t r;
int32_t i;
} conv;
conv.r = result;
int32_t e = expected[x][y];
EXPECT_TRUE(e == 0 ? conv.i == 0 : true) << "x=" << c[x] << " y=" << c[y] << " res=" <<
conv.r;
EXPECT_TRUE(e < 0 ? conv.i < 0 : true) << "x=" << c[x] << " y=" << c[y] << " res=" <<
conv.r;
EXPECT_TRUE(e > 0 ? conv.i > 0 : true) << "x=" << c[x] << " y=" << c[y] << " res=" <<
conv.r;
}
}
// TODO: Deallocate things.
// Tests done.
#else
LOG(INFO) << "Skipping string_compareto as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping string_compareto as I don't know how to do that on " << kRuntimeISA <<
std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set32_static(void);
extern "C" void art_quick_get32_static(void);
#endif
static void GetSet32Static(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
constexpr size_t num_values = 7;
uint32_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
static_cast<size_t>(values[i]),
0U,
reinterpret_cast<uintptr_t>(&art_quick_set32_static),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_get32_static),
self,
referrer);
EXPECT_EQ(res, values[i]) << "Iteration " << i;
}
#else
LOG(INFO) << "Skipping set32static as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set32static as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set32_instance(void);
extern "C" void art_quick_get32_instance(void);
#endif
static void GetSet32Instance(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f,
Thread* self, mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
constexpr size_t num_values = 7;
uint32_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
static_cast<size_t>(values[i]),
reinterpret_cast<uintptr_t>(&art_quick_set32_instance),
self,
referrer);
int32_t res = f->Get()->GetInt(obj->Get());
EXPECT_EQ(res, static_cast<int32_t>(values[i])) << "Iteration " << i;
res++;
f->Get()->SetInt<false>(obj->Get(), res);
size_t res2 = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
0U,
reinterpret_cast<uintptr_t>(&art_quick_get32_instance),
self,
referrer);
EXPECT_EQ(res, static_cast<int32_t>(res2));
}
#else
LOG(INFO) << "Skipping set32instance as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set32instance as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set_obj_static(void);
extern "C" void art_quick_get_obj_static(void);
static void set_and_check_static(uint32_t f_idx, mirror::Object* val, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
test->Invoke3WithReferrer(static_cast<size_t>(f_idx),
reinterpret_cast<size_t>(val),
0U,
reinterpret_cast<uintptr_t>(&art_quick_set_obj_static),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>(f_idx),
0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_get_obj_static),
self,
referrer);
EXPECT_EQ(res, reinterpret_cast<size_t>(val)) << "Value " << val;
}
#endif
static void GetSetObjStatic(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
set_and_check_static((*f)->GetDexFieldIndex(), nullptr, self, referrer, test);
// Allocate a string object for simplicity.
mirror::String* str = mirror::String::AllocFromModifiedUtf8(self, "Test");
set_and_check_static((*f)->GetDexFieldIndex(), str, self, referrer, test);
set_and_check_static((*f)->GetDexFieldIndex(), nullptr, self, referrer, test);
#else
LOG(INFO) << "Skipping setObjstatic as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping setObjstatic as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set_obj_instance(void);
extern "C" void art_quick_get_obj_instance(void);
static void set_and_check_instance(Handle<mirror::ArtField>* f, mirror::Object* trg,
mirror::Object* val, Thread* self, mirror::ArtMethod* referrer,
StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(trg),
reinterpret_cast<size_t>(val),
reinterpret_cast<uintptr_t>(&art_quick_set_obj_instance),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(trg),
0U,
reinterpret_cast<uintptr_t>(&art_quick_get_obj_instance),
self,
referrer);
EXPECT_EQ(res, reinterpret_cast<size_t>(val)) << "Value " << val;
EXPECT_EQ(val, f->Get()->GetObj(trg));
}
#endif
static void GetSetObjInstance(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f,
Thread* self, mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
set_and_check_instance(f, obj->Get(), nullptr, self, referrer, test);
// Allocate a string object for simplicity.
mirror::String* str = mirror::String::AllocFromModifiedUtf8(self, "Test");
set_and_check_instance(f, obj->Get(), str, self, referrer, test);
set_and_check_instance(f, obj->Get(), nullptr, self, referrer, test);
#else
LOG(INFO) << "Skipping setObjinstance as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping setObjinstance as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
// TODO: Complete these tests for 32b architectures.
#if defined(__x86_64__) || defined(__aarch64__)
extern "C" void art_quick_set64_static(void);
extern "C" void art_quick_get64_static(void);
#endif
static void GetSet64Static(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__x86_64__) || defined(__aarch64__)
constexpr size_t num_values = 8;
uint64_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF, 0xFFFFFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3UWithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
values[i],
reinterpret_cast<uintptr_t>(&art_quick_set64_static),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_get64_static),
self,
referrer);
EXPECT_EQ(res, values[i]) << "Iteration " << i;
}
#else
LOG(INFO) << "Skipping set64static as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set64static as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__x86_64__) || defined(__aarch64__)
extern "C" void art_quick_set64_instance(void);
extern "C" void art_quick_get64_instance(void);
#endif
static void GetSet64Instance(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f,
Thread* self, mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__x86_64__) || defined(__aarch64__)
constexpr size_t num_values = 8;
uint64_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF, 0xFFFFFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
static_cast<size_t>(values[i]),
reinterpret_cast<uintptr_t>(&art_quick_set64_instance),
self,
referrer);
int64_t res = f->Get()->GetLong(obj->Get());
EXPECT_EQ(res, static_cast<int64_t>(values[i])) << "Iteration " << i;
res++;
f->Get()->SetLong<false>(obj->Get(), res);
size_t res2 = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
0U,
reinterpret_cast<uintptr_t>(&art_quick_get64_instance),
self,
referrer);
EXPECT_EQ(res, static_cast<int64_t>(res2));
}
#else
LOG(INFO) << "Skipping set64instance as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set64instance as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
static void TestFields(Thread* self, StubTest* test, Primitive::Type test_type) {
// garbage is created during ClassLinker::Init
JNIEnv* env = Thread::Current()->GetJniEnv();
jclass jc = env->FindClass("AllFields");
CHECK(jc != NULL);
jobject o = env->AllocObject(jc);
CHECK(o != NULL);
ScopedObjectAccess soa(self);
StackHandleScope<5> hs(self);
Handle<mirror::Object> obj(hs.NewHandle(soa.Decode<mirror::Object*>(o)));
Handle<mirror::Class> c(hs.NewHandle(obj->GetClass()));
// Need a method as a referrer
Handle<mirror::ArtMethod> m(hs.NewHandle(c->GetDirectMethod(0)));
// Play with it...
// Static fields.
{
Handle<mirror::ObjectArray<mirror::ArtField>> fields(hs.NewHandle(c.Get()->GetSFields()));
int32_t num_fields = fields->GetLength();
for (int32_t i = 0; i < num_fields; ++i) {
StackHandleScope<1> hs(self);
Handle<mirror::ArtField> f(hs.NewHandle(fields->Get(i)));
Primitive::Type type = f->GetTypeAsPrimitiveType();
switch (type) {
case Primitive::Type::kPrimInt:
if (test_type == type) {
GetSet32Static(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimLong:
if (test_type == type) {
GetSet64Static(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimNot:
// Don't try array.
if (test_type == type && f->GetTypeDescriptor()[0] != '[') {
GetSetObjStatic(&obj, &f, self, m.Get(), test);
}
break;
default:
break; // Skip.
}
}
}
// Instance fields.
{
Handle<mirror::ObjectArray<mirror::ArtField>> fields(hs.NewHandle(c.Get()->GetIFields()));
int32_t num_fields = fields->GetLength();
for (int32_t i = 0; i < num_fields; ++i) {
StackHandleScope<1> hs(self);
Handle<mirror::ArtField> f(hs.NewHandle(fields->Get(i)));
Primitive::Type type = f->GetTypeAsPrimitiveType();
switch (type) {
case Primitive::Type::kPrimInt:
if (test_type == type) {
GetSet32Instance(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimLong:
if (test_type == type) {
GetSet64Instance(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimNot:
// Don't try array.
if (test_type == type && f->GetTypeDescriptor()[0] != '[') {
GetSetObjInstance(&obj, &f, self, m.Get(), test);
}
break;
default:
break; // Skip.
}
}
}
// TODO: Deallocate things.
}
TEST_F(StubTest, Fields32) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
self->TransitionFromSuspendedToRunnable();
LoadDex("AllFields");
bool started = runtime_->Start();
CHECK(started);
TestFields(self, this, Primitive::Type::kPrimInt);
}
TEST_F(StubTest, FieldsObj) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
self->TransitionFromSuspendedToRunnable();
LoadDex("AllFields");
bool started = runtime_->Start();
CHECK(started);
TestFields(self, this, Primitive::Type::kPrimNot);
}
TEST_F(StubTest, Fields64) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
self->TransitionFromSuspendedToRunnable();
LoadDex("AllFields");
bool started = runtime_->Start();
CHECK(started);
TestFields(self, this, Primitive::Type::kPrimLong);
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_imt_conflict_trampoline(void);
#endif
TEST_F(StubTest, IMT) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
StackHandleScope<7> hs(self);
JNIEnv* env = Thread::Current()->GetJniEnv();
// ArrayList
// Load ArrayList and used methods (JNI).
jclass arraylist_jclass = env->FindClass("java/util/ArrayList");
ASSERT_NE(nullptr, arraylist_jclass);
jmethodID arraylist_constructor = env->GetMethodID(arraylist_jclass, "<init>", "()V");
ASSERT_NE(nullptr, arraylist_constructor);
jmethodID contains_jmethod = env->GetMethodID(arraylist_jclass, "contains", "(Ljava/lang/Object;)Z");
ASSERT_NE(nullptr, contains_jmethod);
jmethodID add_jmethod = env->GetMethodID(arraylist_jclass, "add", "(Ljava/lang/Object;)Z");
ASSERT_NE(nullptr, add_jmethod);
// Get mirror representation.
Handle<mirror::ArtMethod> contains_amethod(hs.NewHandle(soa.DecodeMethod(contains_jmethod)));
// Patch up ArrayList.contains.
if (contains_amethod.Get()->GetEntryPointFromQuickCompiledCode() == nullptr) {
contains_amethod.Get()->SetEntryPointFromQuickCompiledCode(reinterpret_cast<void*>(
GetTlsPtr(self)->quick_entrypoints.pQuickToInterpreterBridge));
}
// List
// Load List and used methods (JNI).
jclass list_jclass = env->FindClass("java/util/List");
ASSERT_NE(nullptr, list_jclass);
jmethodID inf_contains_jmethod = env->GetMethodID(list_jclass, "contains", "(Ljava/lang/Object;)Z");
ASSERT_NE(nullptr, inf_contains_jmethod);
// Get mirror representation.
Handle<mirror::ArtMethod> inf_contains(hs.NewHandle(soa.DecodeMethod(inf_contains_jmethod)));
// Object
jclass obj_jclass = env->FindClass("java/lang/Object");
ASSERT_NE(nullptr, obj_jclass);
jmethodID obj_constructor = env->GetMethodID(obj_jclass, "<init>", "()V");
ASSERT_NE(nullptr, obj_constructor);
// Sanity check: check that there is a conflict for List.contains in ArrayList.
mirror::Class* arraylist_class = soa.Decode<mirror::Class*>(arraylist_jclass);
mirror::ArtMethod* m = arraylist_class->GetImTable()->Get(
inf_contains->GetDexMethodIndex() % ClassLinker::kImtSize);
if (!m->IsImtConflictMethod()) {
LOG(WARNING) << "Test is meaningless, no IMT conflict in setup: " <<
PrettyMethod(m, true);
LOG(WARNING) << "Please update StubTest.IMT.";
return;
}
// Create instances.
jobject jarray_list = env->NewObject(arraylist_jclass, arraylist_constructor);
ASSERT_NE(nullptr, jarray_list);
Handle<mirror::Object> array_list(hs.NewHandle(soa.Decode<mirror::Object*>(jarray_list)));
jobject jobj = env->NewObject(obj_jclass, obj_constructor);
ASSERT_NE(nullptr, jobj);
Handle<mirror::Object> obj(hs.NewHandle(soa.Decode<mirror::Object*>(jobj)));
// Invoke.
size_t result =
Invoke3WithReferrerAndHidden(0U, reinterpret_cast<size_t>(array_list.Get()),
reinterpret_cast<size_t>(obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_imt_conflict_trampoline),
self, contains_amethod.Get(),
static_cast<size_t>(inf_contains.Get()->GetDexMethodIndex()));
ASSERT_FALSE(self->IsExceptionPending());
EXPECT_EQ(static_cast<size_t>(JNI_FALSE), result);
// Add object.
env->CallBooleanMethod(jarray_list, add_jmethod, jobj);
ASSERT_FALSE(self->IsExceptionPending()) << PrettyTypeOf(self->GetException(nullptr));
// Invoke again.
result = Invoke3WithReferrerAndHidden(0U, reinterpret_cast<size_t>(array_list.Get()),
reinterpret_cast<size_t>(obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_imt_conflict_trampoline),
self, contains_amethod.Get(),
static_cast<size_t>(inf_contains.Get()->GetDexMethodIndex()));
ASSERT_FALSE(self->IsExceptionPending());
EXPECT_EQ(static_cast<size_t>(JNI_TRUE), result);
#else
LOG(INFO) << "Skipping imt as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping imt as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__arm__) || defined(__aarch64__)
extern "C" void art_quick_indexof(void);
#endif
TEST_F(StubTest, StringIndexOf) {
#if defined(__arm__) || defined(__aarch64__)
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
// Create some strings
// Use array so we can index into it and use a matrix for expected results
// Setup: The first half is standard. The second half uses a non-zero offset.
// TODO: Shared backing arrays.
static constexpr size_t kStringCount = 7;
const char* c_str[kStringCount] = { "", "a", "ba", "cba", "dcba", "edcba", "asdfghjkl" };
static constexpr size_t kCharCount = 5;
const char c_char[kCharCount] = { 'a', 'b', 'c', 'd', 'e' };
StackHandleScope<kStringCount> hs(self);
Handle<mirror::String> s[kStringCount];
for (size_t i = 0; i < kStringCount; ++i) {
s[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), c_str[i]));
}
// Matrix of expectations. First component is first parameter. Note we only check against the
// sign, not the value. As we are testing random offsets, we need to compute this and need to
// rely on String::CompareTo being correct.
static constexpr size_t kMaxLen = 9;
DCHECK_LE(strlen(c_str[kStringCount-1]), kMaxLen) << "Please fix the indexof test.";
// Last dimension: start, offset by 1.
int32_t expected[kStringCount][kCharCount][kMaxLen + 3];
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kCharCount; ++y) {
for (size_t z = 0; z <= kMaxLen + 2; ++z) {
expected[x][y][z] = s[x]->FastIndexOf(c_char[y], static_cast<int32_t>(z) - 1);
}
}
}
// Play with it...
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kCharCount; ++y) {
for (size_t z = 0; z <= kMaxLen + 2; ++z) {
int32_t start = static_cast<int32_t>(z) - 1;
// Test string_compareto x y
size_t result = Invoke3(reinterpret_cast<size_t>(s[x].Get()), c_char[y], start,
reinterpret_cast<uintptr_t>(&art_quick_indexof), self);
EXPECT_FALSE(self->IsExceptionPending());
// The result is a 32b signed integer
union {
size_t r;
int32_t i;
} conv;
conv.r = result;
EXPECT_EQ(expected[x][y][z], conv.i) << "Wrong result for " << c_str[x] << " / " <<
c_char[y] << " @ " << start;
}
}
}
// TODO: Deallocate things.
// Tests done.
#else
LOG(INFO) << "Skipping indexof as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping indexof as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
} // namespace art
Disable StubTest.IndexOf if heap poisoning is enabled for now.
art_quick_indexof does not support heap poisoning yet.
Bug: 12687968
Change-Id: Ibc497cc782399f0d8e0d3dca59e1ebb358fe83a5
/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "common_runtime_test.h"
#include "mirror/art_field-inl.h"
#include "mirror/art_method-inl.h"
#include "mirror/class-inl.h"
#include "mirror/string-inl.h"
#include <cstdio>
namespace art {
class StubTest : public CommonRuntimeTest {
protected:
// We need callee-save methods set up in the Runtime for exceptions.
void SetUp() OVERRIDE {
// Do the normal setup.
CommonRuntimeTest::SetUp();
{
// Create callee-save methods
ScopedObjectAccess soa(Thread::Current());
runtime_->SetInstructionSet(kRuntimeISA);
for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i);
if (!runtime_->HasCalleeSaveMethod(type)) {
runtime_->SetCalleeSaveMethod(runtime_->CreateCalleeSaveMethod(type), type);
}
}
}
}
void SetUpRuntimeOptions(Runtime::Options *options) OVERRIDE {
// Use a smaller heap
for (std::pair<std::string, const void*>& pair : *options) {
if (pair.first.find("-Xmx") == 0) {
pair.first = "-Xmx4M"; // Smallest we can go.
}
}
options->push_back(std::make_pair("-Xint", nullptr));
}
// Helper function needed since TEST_F makes a new class.
Thread::tls_ptr_sized_values* GetTlsPtr(Thread* self) {
return &self->tlsPtr_;
}
public:
size_t Invoke3(size_t arg0, size_t arg1, size_t arg2, uintptr_t code, Thread* self) {
return Invoke3WithReferrer(arg0, arg1, arg2, code, self, nullptr);
}
// TODO: Set up a frame according to referrer's specs.
size_t Invoke3WithReferrer(size_t arg0, size_t arg1, size_t arg2, uintptr_t code, Thread* self,
mirror::ArtMethod* referrer) {
// Push a transition back into managed code onto the linked list in thread.
ManagedStack fragment;
self->PushManagedStackFragment(&fragment);
size_t result;
size_t fpr_result = 0;
#if defined(__i386__)
// TODO: Set the thread?
__asm__ __volatile__(
"subl $12, %%esp\n\t" // Align stack.
"pushl %[referrer]\n\t" // Store referrer.
"call *%%edi\n\t" // Call the stub
"addl $16, %%esp" // Pop referrer
: "=a" (result)
// Use the result from eax
: "a"(arg0), "c"(arg1), "d"(arg2), "D"(code), [referrer]"r"(referrer)
// This places code into edi, arg0 into eax, arg1 into ecx, and arg2 into edx
: "memory"); // clobber.
// TODO: Should we clobber the other registers? EBX gets clobbered by some of the stubs,
// but compilation fails when declaring that.
#elif defined(__arm__)
__asm__ __volatile__(
"push {r1-r12, lr}\n\t" // Save state, 13*4B = 52B
".cfi_adjust_cfa_offset 52\n\t"
"push {r9}\n\t"
".cfi_adjust_cfa_offset 4\n\t"
"mov r9, %[referrer]\n\n"
"str r9, [sp, #-8]!\n\t" // Push referrer, +8B padding so 16B aligned
".cfi_adjust_cfa_offset 8\n\t"
"ldr r9, [sp, #8]\n\t"
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #20\n\t"
"str %[arg0], [sp]\n\t"
"str %[arg1], [sp, #4]\n\t"
"str %[arg2], [sp, #8]\n\t"
"str %[code], [sp, #12]\n\t"
"str %[self], [sp, #16]\n\t"
"ldr r0, [sp]\n\t"
"ldr r1, [sp, #4]\n\t"
"ldr r2, [sp, #8]\n\t"
"ldr r3, [sp, #12]\n\t"
"ldr r9, [sp, #16]\n\t"
"add sp, sp, #20\n\t"
"blx r3\n\t" // Call the stub
"add sp, sp, #12\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -12\n\t"
"pop {r1-r12, lr}\n\t" // Restore state
".cfi_adjust_cfa_offset -52\n\t"
"mov %[result], r0\n\t" // Save the result
: [result] "=r" (result)
// Use the result from r0
: [arg0] "r"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer)
: "memory"); // clobber.
#elif defined(__aarch64__)
__asm__ __volatile__(
// Spill x0-x7 which we say we don't clobber. May contain args.
"sub sp, sp, #64\n\t"
".cfi_adjust_cfa_offset 64\n\t"
"stp x0, x1, [sp]\n\t"
"stp x2, x3, [sp, #16]\n\t"
"stp x4, x5, [sp, #32]\n\t"
"stp x6, x7, [sp, #48]\n\t"
"sub sp, sp, #16\n\t" // Reserve stack space, 16B aligned
".cfi_adjust_cfa_offset 16\n\t"
"str %[referrer], [sp]\n\t" // referrer
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #48\n\t"
".cfi_adjust_cfa_offset 48\n\t"
// All things are "r" constraints, so direct str/stp should work.
"stp %[arg0], %[arg1], [sp]\n\t"
"stp %[arg2], %[code], [sp, #16]\n\t"
"str %[self], [sp, #32]\n\t"
// Now we definitely have x0-x3 free, use it to garble d8 - d15
"movk x0, #0xfad0\n\t"
"movk x0, #0xebad, lsl #16\n\t"
"movk x0, #0xfad0, lsl #32\n\t"
"movk x0, #0xebad, lsl #48\n\t"
"fmov d8, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d9, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d10, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d11, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d12, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d13, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d14, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d15, x0\n\t"
// Load call params into the right registers.
"ldp x0, x1, [sp]\n\t"
"ldp x2, x3, [sp, #16]\n\t"
"ldr x18, [sp, #32]\n\t"
"add sp, sp, #48\n\t"
".cfi_adjust_cfa_offset -48\n\t"
"blr x3\n\t" // Call the stub
"mov x8, x0\n\t" // Store result
"add sp, sp, #16\n\t" // Drop the quick "frame"
".cfi_adjust_cfa_offset -16\n\t"
// Test d8 - d15. We can use x1 and x2.
"movk x1, #0xfad0\n\t"
"movk x1, #0xebad, lsl #16\n\t"
"movk x1, #0xfad0, lsl #32\n\t"
"movk x1, #0xebad, lsl #48\n\t"
"fmov x2, d8\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d9\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d10\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d11\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d12\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d13\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d14\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d15\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"mov x9, #0\n\t" // Use x9 as flag, in clobber list
// Finish up.
"2:\n\t"
"ldp x0, x1, [sp]\n\t" // Restore stuff not named clobbered, may contain fpr_result
"ldp x2, x3, [sp, #16]\n\t"
"ldp x4, x5, [sp, #32]\n\t"
"ldp x6, x7, [sp, #48]\n\t"
"add sp, sp, #64\n\t" // Free stack space, now sp as on entry
".cfi_adjust_cfa_offset -64\n\t"
"str x9, %[fpr_result]\n\t" // Store the FPR comparison result
"mov %[result], x8\n\t" // Store the call result
"b 3f\n\t" // Goto end
// Failed fpr verification.
"1:\n\t"
"mov x9, #1\n\t"
"b 2b\n\t" // Goto finish-up
// End
"3:\n\t"
: [result] "=r" (result)
// Use the result from r0
: [arg0] "0"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer), [fpr_result] "m" (fpr_result)
: "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20",
"x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x30",
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
"d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
"d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
"memory"); // clobber.
#elif defined(__x86_64__)
// Note: Uses the native convention
// TODO: Set the thread?
__asm__ __volatile__(
"pushq %[referrer]\n\t" // Push referrer
"pushq (%%rsp)\n\t" // & 16B alignment padding
".cfi_adjust_cfa_offset 16\n\t"
"call *%%rax\n\t" // Call the stub
"addq $16, %%rsp\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -16\n\t"
: "=a" (result)
// Use the result from rax
: "D"(arg0), "S"(arg1), "d"(arg2), "a"(code), [referrer] "m"(referrer)
// This places arg0 into rdi, arg1 into rsi, arg2 into rdx, and code into rax
: "rbx", "rcx", "rbp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"memory"); // clobber all
// TODO: Should we clobber the other registers?
#else
LOG(WARNING) << "Was asked to invoke for an architecture I do not understand.";
result = 0;
#endif
// Pop transition.
self->PopManagedStackFragment(fragment);
fp_result = fpr_result;
EXPECT_EQ(0U, fp_result);
return result;
}
// TODO: Set up a frame according to referrer's specs.
size_t Invoke3WithReferrerAndHidden(size_t arg0, size_t arg1, size_t arg2, uintptr_t code,
Thread* self, mirror::ArtMethod* referrer, size_t hidden) {
// Push a transition back into managed code onto the linked list in thread.
ManagedStack fragment;
self->PushManagedStackFragment(&fragment);
size_t result;
size_t fpr_result = 0;
#if defined(__i386__)
// TODO: Set the thread?
__asm__ __volatile__(
"movd %[hidden], %%xmm0\n\t"
"subl $12, %%esp\n\t" // Align stack.
"pushl %[referrer]\n\t" // Store referrer
"call *%%edi\n\t" // Call the stub
"addl $16, %%esp" // Pop referrer
: "=a" (result)
// Use the result from eax
: "a"(arg0), "c"(arg1), "d"(arg2), "D"(code), [referrer]"m"(referrer), [hidden]"r"(hidden)
// This places code into edi, arg0 into eax, arg1 into ecx, and arg2 into edx
: "memory"); // clobber.
// TODO: Should we clobber the other registers? EBX gets clobbered by some of the stubs,
// but compilation fails when declaring that.
#elif defined(__arm__)
__asm__ __volatile__(
"push {r1-r12, lr}\n\t" // Save state, 13*4B = 52B
".cfi_adjust_cfa_offset 52\n\t"
"push {r9}\n\t"
".cfi_adjust_cfa_offset 4\n\t"
"mov r9, %[referrer]\n\n"
"str r9, [sp, #-8]!\n\t" // Push referrer, +8B padding so 16B aligned
".cfi_adjust_cfa_offset 8\n\t"
"ldr r9, [sp, #8]\n\t"
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #24\n\t"
"str %[arg0], [sp]\n\t"
"str %[arg1], [sp, #4]\n\t"
"str %[arg2], [sp, #8]\n\t"
"str %[code], [sp, #12]\n\t"
"str %[self], [sp, #16]\n\t"
"str %[hidden], [sp, #20]\n\t"
"ldr r0, [sp]\n\t"
"ldr r1, [sp, #4]\n\t"
"ldr r2, [sp, #8]\n\t"
"ldr r3, [sp, #12]\n\t"
"ldr r9, [sp, #16]\n\t"
"ldr r12, [sp, #20]\n\t"
"add sp, sp, #24\n\t"
"blx r3\n\t" // Call the stub
"add sp, sp, #12\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -12\n\t"
"pop {r1-r12, lr}\n\t" // Restore state
".cfi_adjust_cfa_offset -52\n\t"
"mov %[result], r0\n\t" // Save the result
: [result] "=r" (result)
// Use the result from r0
: [arg0] "r"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer), [hidden] "r"(hidden)
: "memory"); // clobber.
#elif defined(__aarch64__)
__asm__ __volatile__(
// Spill x0-x7 which we say we don't clobber. May contain args.
"sub sp, sp, #64\n\t"
".cfi_adjust_cfa_offset 64\n\t"
"stp x0, x1, [sp]\n\t"
"stp x2, x3, [sp, #16]\n\t"
"stp x4, x5, [sp, #32]\n\t"
"stp x6, x7, [sp, #48]\n\t"
"sub sp, sp, #16\n\t" // Reserve stack space, 16B aligned
".cfi_adjust_cfa_offset 16\n\t"
"str %[referrer], [sp]\n\t" // referrer
// Push everything on the stack, so we don't rely on the order. What a mess. :-(
"sub sp, sp, #48\n\t"
".cfi_adjust_cfa_offset 48\n\t"
// All things are "r" constraints, so direct str/stp should work.
"stp %[arg0], %[arg1], [sp]\n\t"
"stp %[arg2], %[code], [sp, #16]\n\t"
"stp %[self], %[hidden], [sp, #32]\n\t"
// Now we definitely have x0-x3 free, use it to garble d8 - d15
"movk x0, #0xfad0\n\t"
"movk x0, #0xebad, lsl #16\n\t"
"movk x0, #0xfad0, lsl #32\n\t"
"movk x0, #0xebad, lsl #48\n\t"
"fmov d8, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d9, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d10, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d11, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d12, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d13, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d14, x0\n\t"
"add x0, x0, 1\n\t"
"fmov d15, x0\n\t"
// Load call params into the right registers.
"ldp x0, x1, [sp]\n\t"
"ldp x2, x3, [sp, #16]\n\t"
"ldp x18, x12, [sp, #32]\n\t"
"add sp, sp, #48\n\t"
".cfi_adjust_cfa_offset -48\n\t"
"blr x3\n\t" // Call the stub
"mov x8, x0\n\t" // Store result
"add sp, sp, #16\n\t" // Drop the quick "frame"
".cfi_adjust_cfa_offset -16\n\t"
// Test d8 - d15. We can use x1 and x2.
"movk x1, #0xfad0\n\t"
"movk x1, #0xebad, lsl #16\n\t"
"movk x1, #0xfad0, lsl #32\n\t"
"movk x1, #0xebad, lsl #48\n\t"
"fmov x2, d8\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d9\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d10\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d11\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d12\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d13\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d14\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"add x1, x1, 1\n\t"
"fmov x2, d15\n\t"
"cmp x1, x2\n\t"
"b.ne 1f\n\t"
"mov x9, #0\n\t" // Use x9 as flag, in clobber list
// Finish up.
"2:\n\t"
"ldp x0, x1, [sp]\n\t" // Restore stuff not named clobbered, may contain fpr_result
"ldp x2, x3, [sp, #16]\n\t"
"ldp x4, x5, [sp, #32]\n\t"
"ldp x6, x7, [sp, #48]\n\t"
"add sp, sp, #64\n\t" // Free stack space, now sp as on entry
".cfi_adjust_cfa_offset -64\n\t"
"str x9, %[fpr_result]\n\t" // Store the FPR comparison result
"mov %[result], x8\n\t" // Store the call result
"b 3f\n\t" // Goto end
// Failed fpr verification.
"1:\n\t"
"mov x9, #1\n\t"
"b 2b\n\t" // Goto finish-up
// End
"3:\n\t"
: [result] "=r" (result)
// Use the result from r0
: [arg0] "0"(arg0), [arg1] "r"(arg1), [arg2] "r"(arg2), [code] "r"(code), [self] "r"(self),
[referrer] "r"(referrer), [hidden] "r"(hidden), [fpr_result] "m" (fpr_result)
: "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20",
"x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x30",
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
"d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
"d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
"d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
"memory"); // clobber.
#elif defined(__x86_64__)
// Note: Uses the native convention
// TODO: Set the thread?
__asm__ __volatile__(
"movq %[hidden], %%r9\n\t" // No need to save r9, listed as clobbered
"movd %%r9, %%xmm0\n\t"
"pushq %[referrer]\n\t" // Push referrer
"pushq (%%rsp)\n\t" // & 16B alignment padding
".cfi_adjust_cfa_offset 16\n\t"
"call *%%rax\n\t" // Call the stub
"addq $16, %%rsp\n\t" // Pop nullptr and padding
".cfi_adjust_cfa_offset -16\n\t"
: "=a" (result)
// Use the result from rax
: "D"(arg0), "S"(arg1), "d"(arg2), "a"(code), [referrer] "m"(referrer), [hidden] "m"(hidden)
// This places arg0 into rdi, arg1 into rsi, arg2 into rdx, and code into rax
: "rbx", "rcx", "rbp", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"memory"); // clobber all
// TODO: Should we clobber the other registers?
#else
LOG(WARNING) << "Was asked to invoke for an architecture I do not understand.";
result = 0;
#endif
// Pop transition.
self->PopManagedStackFragment(fragment);
fp_result = fpr_result;
EXPECT_EQ(0U, fp_result);
return result;
}
// Method with 32b arg0, 64b arg1
size_t Invoke3UWithReferrer(size_t arg0, uint64_t arg1, uintptr_t code, Thread* self,
mirror::ArtMethod* referrer) {
#if defined(__x86_64__) || defined(__aarch64__)
// Just pass through.
return Invoke3WithReferrer(arg0, arg1, 0U, code, self, referrer);
#else
// Need to split up arguments.
uint32_t lower = static_cast<uint32_t>(arg1 & 0xFFFFFFFF);
uint32_t upper = static_cast<uint32_t>((arg1 >> 32) & 0xFFFFFFFF);
return Invoke3WithReferrer(arg0, lower, upper, code, self, referrer);
#endif
}
// Method with 32b arg0, 32b arg1, 64b arg2
size_t Invoke3UUWithReferrer(uint32_t arg0, uint32_t arg1, uint64_t arg2, uintptr_t code,
Thread* self, mirror::ArtMethod* referrer) {
#if defined(__x86_64__) || defined(__aarch64__)
// Just pass through.
return Invoke3WithReferrer(arg0, arg1, arg2, code, self, referrer);
#else
// TODO: Needs 4-param invoke.
return 0;
#endif
}
protected:
size_t fp_result;
};
#if defined(__i386__) || defined(__x86_64__)
extern "C" void art_quick_memcpy(void);
#endif
TEST_F(StubTest, Memcpy) {
#if defined(__i386__) || defined(__x86_64__)
Thread* self = Thread::Current();
uint32_t orig[20];
uint32_t trg[20];
for (size_t i = 0; i < 20; ++i) {
orig[i] = i;
trg[i] = 0;
}
Invoke3(reinterpret_cast<size_t>(&trg[4]), reinterpret_cast<size_t>(&orig[4]),
10 * sizeof(uint32_t), reinterpret_cast<uintptr_t>(&art_quick_memcpy), self);
EXPECT_EQ(orig[0], trg[0]);
for (size_t i = 1; i < 4; ++i) {
EXPECT_NE(orig[i], trg[i]);
}
for (size_t i = 4; i < 14; ++i) {
EXPECT_EQ(orig[i], trg[i]);
}
for (size_t i = 14; i < 20; ++i) {
EXPECT_NE(orig[i], trg[i]);
}
// TODO: Test overlapping?
#else
LOG(INFO) << "Skipping memcpy as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping memcpy as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_lock_object(void);
#endif
TEST_F(StubTest, LockObject) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
static constexpr size_t kThinLockLoops = 100;
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(soa.Self());
Handle<mirror::String> obj(
hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
LockWord lock = obj->GetLockWord(false);
LockWord::LockState old_state = lock.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, old_state);
Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
LockWord lock_after = obj->GetLockWord(false);
LockWord::LockState new_state = lock_after.GetState();
EXPECT_EQ(LockWord::LockState::kThinLocked, new_state);
EXPECT_EQ(lock_after.ThinLockCount(), 0U); // Thin lock starts count at zero
for (size_t i = 1; i < kThinLockLoops; ++i) {
Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
// Check we're at lock count i
LockWord l_inc = obj->GetLockWord(false);
LockWord::LockState l_inc_state = l_inc.GetState();
EXPECT_EQ(LockWord::LockState::kThinLocked, l_inc_state);
EXPECT_EQ(l_inc.ThinLockCount(), i);
}
// Force a fat lock by running identity hashcode to fill up lock word.
Handle<mirror::String> obj2(hs.NewHandle(
mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
obj2->IdentityHashCode();
Invoke3(reinterpret_cast<size_t>(obj2.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
LockWord lock_after2 = obj2->GetLockWord(false);
LockWord::LockState new_state2 = lock_after2.GetState();
EXPECT_EQ(LockWord::LockState::kFatLocked, new_state2);
EXPECT_NE(lock_after2.FatLockMonitor(), static_cast<Monitor*>(nullptr));
// Test done.
#else
LOG(INFO) << "Skipping lock_object as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping lock_object as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
class RandGen {
public:
explicit RandGen(uint32_t seed) : val_(seed) {}
uint32_t next() {
val_ = val_ * 48271 % 2147483647 + 13;
return val_;
}
uint32_t val_;
};
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_lock_object(void);
extern "C" void art_quick_unlock_object(void);
#endif
// NO_THREAD_SAFETY_ANALYSIS as we do not want to grab exclusive mutator lock for MonitorInfo.
static void TestUnlockObject(StubTest* test) NO_THREAD_SAFETY_ANALYSIS {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
static constexpr size_t kThinLockLoops = 100;
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
static constexpr size_t kNumberOfLocks = 10; // Number of objects = lock
StackHandleScope<kNumberOfLocks + 1> hs(self);
Handle<mirror::String> obj(
hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
LockWord lock = obj->GetLockWord(false);
LockWord::LockState old_state = lock.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, old_state);
test->Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
// This should be an illegal monitor state.
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
LockWord lock_after = obj->GetLockWord(false);
LockWord::LockState new_state = lock_after.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, new_state);
test->Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
LockWord lock_after2 = obj->GetLockWord(false);
LockWord::LockState new_state2 = lock_after2.GetState();
EXPECT_EQ(LockWord::LockState::kThinLocked, new_state2);
test->Invoke3(reinterpret_cast<size_t>(obj.Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
LockWord lock_after3 = obj->GetLockWord(false);
LockWord::LockState new_state3 = lock_after3.GetState();
EXPECT_EQ(LockWord::LockState::kUnlocked, new_state3);
// Stress test:
// Keep a number of objects and their locks in flight. Randomly lock or unlock one of them in
// each step.
RandGen r(0x1234);
constexpr size_t kIterations = 10000; // Number of iterations
constexpr size_t kMoveToFat = 1000; // Chance of 1:kMoveFat to make a lock fat.
size_t counts[kNumberOfLocks];
bool fat[kNumberOfLocks]; // Whether a lock should be thin or fat.
Handle<mirror::String> objects[kNumberOfLocks];
// Initialize = allocate.
for (size_t i = 0; i < kNumberOfLocks; ++i) {
counts[i] = 0;
fat[i] = false;
objects[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), ""));
}
for (size_t i = 0; i < kIterations; ++i) {
// Select which lock to update.
size_t index = r.next() % kNumberOfLocks;
// Make lock fat?
if (!fat[index] && (r.next() % kMoveToFat == 0)) {
fat[index] = true;
objects[index]->IdentityHashCode();
LockWord lock_iter = objects[index]->GetLockWord(false);
LockWord::LockState iter_state = lock_iter.GetState();
if (counts[index] == 0) {
EXPECT_EQ(LockWord::LockState::kHashCode, iter_state);
} else {
EXPECT_EQ(LockWord::LockState::kFatLocked, iter_state);
}
} else {
bool lock; // Whether to lock or unlock in this step.
if (counts[index] == 0) {
lock = true;
} else if (counts[index] == kThinLockLoops) {
lock = false;
} else {
// Randomly.
lock = r.next() % 2 == 0;
}
if (lock) {
test->Invoke3(reinterpret_cast<size_t>(objects[index].Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_lock_object), self);
counts[index]++;
} else {
test->Invoke3(reinterpret_cast<size_t>(objects[index].Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
counts[index]--;
}
EXPECT_FALSE(self->IsExceptionPending());
// Check the new state.
LockWord lock_iter = objects[index]->GetLockWord(true);
LockWord::LockState iter_state = lock_iter.GetState();
if (fat[index]) {
// Abuse MonitorInfo.
EXPECT_EQ(LockWord::LockState::kFatLocked, iter_state) << index;
MonitorInfo info(objects[index].Get());
EXPECT_EQ(counts[index], info.entry_count_) << index;
} else {
if (counts[index] > 0) {
EXPECT_EQ(LockWord::LockState::kThinLocked, iter_state);
EXPECT_EQ(counts[index] - 1, lock_iter.ThinLockCount());
} else {
EXPECT_EQ(LockWord::LockState::kUnlocked, iter_state);
}
}
}
}
// Unlock the remaining count times and then check it's unlocked. Then deallocate.
// Go reverse order to correctly handle Handles.
for (size_t i = 0; i < kNumberOfLocks; ++i) {
size_t index = kNumberOfLocks - 1 - i;
size_t count = counts[index];
while (count > 0) {
test->Invoke3(reinterpret_cast<size_t>(objects[index].Get()), 0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_unlock_object), self);
count--;
}
LockWord lock_after4 = objects[index]->GetLockWord(false);
LockWord::LockState new_state4 = lock_after4.GetState();
EXPECT_TRUE(LockWord::LockState::kUnlocked == new_state4
|| LockWord::LockState::kFatLocked == new_state4);
}
// Test done.
#else
LOG(INFO) << "Skipping unlock_object as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping unlock_object as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
TEST_F(StubTest, UnlockObject) {
TestUnlockObject(this);
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_check_cast(void);
#endif
TEST_F(StubTest, CheckCast) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
Thread* self = Thread::Current();
// Find some classes.
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(soa.Self());
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
Handle<mirror::Class> c2(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;")));
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(c.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(c2.Get()), reinterpret_cast<size_t>(c2.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(c2.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_FALSE(self->IsExceptionPending());
// TODO: Make the following work. But that would require correct managed frames.
Invoke3(reinterpret_cast<size_t>(c2.Get()), reinterpret_cast<size_t>(c.Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_check_cast), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
#else
LOG(INFO) << "Skipping check_cast as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping check_cast as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_aput_obj_with_null_and_bound_check(void);
// Do not check non-checked ones, we'd need handlers and stuff...
#endif
TEST_F(StubTest, APutObj) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<5> hs(soa.Self());
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
Handle<mirror::Class> ca(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;")));
// Build a string array of size 1
Handle<mirror::ObjectArray<mirror::Object>> array(
hs.NewHandle(mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), ca.Get(), 10)));
// Build a string -> should be assignable
Handle<mirror::String> str_obj(
hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!")));
// Build a generic object -> should fail assigning
Handle<mirror::Object> obj_obj(hs.NewHandle(c->AllocObject(soa.Self())));
// Play with it...
// 1) Success cases
// 1.1) Assign str_obj to array[0..3]
EXPECT_FALSE(self->IsExceptionPending());
Invoke3(reinterpret_cast<size_t>(array.Get()), 0U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(0));
Invoke3(reinterpret_cast<size_t>(array.Get()), 1U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(1));
Invoke3(reinterpret_cast<size_t>(array.Get()), 2U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(2));
Invoke3(reinterpret_cast<size_t>(array.Get()), 3U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(str_obj.Get(), array->Get(3));
// 1.2) Assign null to array[0..3]
Invoke3(reinterpret_cast<size_t>(array.Get()), 0U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(0));
Invoke3(reinterpret_cast<size_t>(array.Get()), 1U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(1));
Invoke3(reinterpret_cast<size_t>(array.Get()), 2U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(2));
Invoke3(reinterpret_cast<size_t>(array.Get()), 3U, reinterpret_cast<size_t>(nullptr),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_EQ(nullptr, array->Get(3));
// TODO: Check _which_ exception is thrown. Then make 3) check that it's the right check order.
// 2) Failure cases (str into str[])
// 2.1) Array = null
// TODO: Throwing NPE needs actual DEX code
// Invoke3(reinterpret_cast<size_t>(nullptr), 0U, reinterpret_cast<size_t>(str_obj.Get()),
// reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
//
// EXPECT_TRUE(self->IsExceptionPending());
// self->ClearException();
// 2.2) Index < 0
Invoke3(reinterpret_cast<size_t>(array.Get()), static_cast<size_t>(-1),
reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
// 2.3) Index > 0
Invoke3(reinterpret_cast<size_t>(array.Get()), 10U, reinterpret_cast<size_t>(str_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
// 3) Failure cases (obj into str[])
Invoke3(reinterpret_cast<size_t>(array.Get()), 0U, reinterpret_cast<size_t>(obj_obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_aput_obj_with_null_and_bound_check), self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
// Tests done.
#else
LOG(INFO) << "Skipping aput_obj as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping aput_obj as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
TEST_F(StubTest, AllocObject) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
// TODO: Check the "Unresolved" allocation stubs
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(soa.Self());
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
// Play with it...
EXPECT_FALSE(self->IsExceptionPending());
{
// Use an arbitrary method from c to use as referrer
size_t result = Invoke3(static_cast<size_t>(c->GetDexTypeIndex()), // type_idx
reinterpret_cast<size_t>(c->GetVirtualMethod(0)), // arbitrary
0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObject),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
}
{
// We can use nullptr in the second argument as we do not need a method here (not used in
// resolved/initialized cases)
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObjectResolved),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
}
{
// We can use nullptr in the second argument as we do not need a method here (not used in
// resolved/initialized cases)
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObjectInitialized),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
}
// Failure tests.
// Out-of-memory.
{
Runtime::Current()->GetHeap()->SetIdealFootprint(1 * GB);
// Array helps to fill memory faster.
Handle<mirror::Class> ca(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
// Use arbitrary large amount for now.
static const size_t kMaxHandles = 1000000;
std::unique_ptr<StackHandleScope<kMaxHandles>> hsp(new StackHandleScope<kMaxHandles>(self));
std::vector<Handle<mirror::Object>> handles;
// Start allocating with 128K
size_t length = 128 * KB / 4;
while (length > 10) {
Handle<mirror::Object> h(hsp->NewHandle<mirror::Object>(
mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), ca.Get(), length / 4)));
if (self->IsExceptionPending() || h.Get() == nullptr) {
self->ClearException();
// Try a smaller length
length = length / 8;
// Use at most half the reported free space.
size_t mem = Runtime::Current()->GetHeap()->GetFreeMemory();
if (length * 8 > mem) {
length = mem / 8;
}
} else {
handles.push_back(h);
}
}
LOG(INFO) << "Used " << handles.size() << " arrays to fill space.";
// Allocate simple objects till it fails.
while (!self->IsExceptionPending()) {
Handle<mirror::Object> h = hsp->NewHandle(c->AllocObject(soa.Self()));
if (!self->IsExceptionPending() && h.Get() != nullptr) {
handles.push_back(h);
}
}
self->ClearException();
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 0U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocObjectInitialized),
self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
EXPECT_EQ(reinterpret_cast<size_t>(nullptr), result);
}
// Tests done.
#else
LOG(INFO) << "Skipping alloc_object as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping alloc_object as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
TEST_F(StubTest, AllocObjectArray) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
// TODO: Check the "Unresolved" allocation stubs
Thread* self = Thread::Current();
// Create an object
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
StackHandleScope<2> hs(self);
Handle<mirror::Class> c(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/Object;")));
// Needed to have a linked method.
Handle<mirror::Class> c_obj(
hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
// Play with it...
EXPECT_FALSE(self->IsExceptionPending());
// For some reason this does not work, as the type_idx is artificial and outside what the
// resolved types of c_obj allow...
if (false) {
// Use an arbitrary method from c to use as referrer
size_t result = Invoke3(static_cast<size_t>(c->GetDexTypeIndex()), // type_idx
reinterpret_cast<size_t>(c_obj->GetVirtualMethod(0)), // arbitrary
10U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocArray),
self);
EXPECT_FALSE(self->IsExceptionPending());
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Array* obj = reinterpret_cast<mirror::Array*>(result);
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
EXPECT_EQ(obj->GetLength(), 10);
}
{
// We can use nullptr in the second argument as we do not need a method here (not used in
// resolved/initialized cases)
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr), 10U,
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocArrayResolved),
self);
EXPECT_FALSE(self->IsExceptionPending()) << PrettyTypeOf(self->GetException(nullptr));
EXPECT_NE(reinterpret_cast<size_t>(nullptr), result);
mirror::Object* obj = reinterpret_cast<mirror::Object*>(result);
EXPECT_TRUE(obj->IsArrayInstance());
EXPECT_TRUE(obj->IsObjectArray());
EXPECT_EQ(c.Get(), obj->GetClass());
VerifyObject(obj);
mirror::Array* array = reinterpret_cast<mirror::Array*>(result);
EXPECT_EQ(array->GetLength(), 10);
}
// Failure tests.
// Out-of-memory.
{
size_t result = Invoke3(reinterpret_cast<size_t>(c.Get()), reinterpret_cast<size_t>(nullptr),
GB, // that should fail...
reinterpret_cast<uintptr_t>(GetTlsPtr(self)->quick_entrypoints.pAllocArrayResolved),
self);
EXPECT_TRUE(self->IsExceptionPending());
self->ClearException();
EXPECT_EQ(reinterpret_cast<size_t>(nullptr), result);
}
// Tests done.
#else
LOG(INFO) << "Skipping alloc_array as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping alloc_array as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_string_compareto(void);
#endif
TEST_F(StubTest, StringCompareTo) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
// TODO: Check the "Unresolved" allocation stubs
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
// Create some strings
// Use array so we can index into it and use a matrix for expected results
// Setup: The first half is standard. The second half uses a non-zero offset.
// TODO: Shared backing arrays.
static constexpr size_t kBaseStringCount = 7;
const char* c[kBaseStringCount] = { "", "", "a", "aa", "ab", "aac", "aac" , };
static constexpr size_t kStringCount = 2 * kBaseStringCount;
StackHandleScope<kStringCount> hs(self);
Handle<mirror::String> s[kStringCount];
for (size_t i = 0; i < kBaseStringCount; ++i) {
s[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), c[i]));
}
RandGen r(0x1234);
for (size_t i = kBaseStringCount; i < kStringCount; ++i) {
s[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), c[i - kBaseStringCount]));
int32_t length = s[i]->GetLength();
if (length > 1) {
// Set a random offset and length.
int32_t new_offset = 1 + (r.next() % (length - 1));
int32_t rest = length - new_offset - 1;
int32_t new_length = 1 + (rest > 0 ? r.next() % rest : 0);
s[i]->SetField32<false>(mirror::String::CountOffset(), new_length);
s[i]->SetField32<false>(mirror::String::OffsetOffset(), new_offset);
}
}
// TODO: wide characters
// Matrix of expectations. First component is first parameter. Note we only check against the
// sign, not the value. As we are testing random offsets, we need to compute this and need to
// rely on String::CompareTo being correct.
int32_t expected[kStringCount][kStringCount];
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kStringCount; ++y) {
expected[x][y] = s[x]->CompareTo(s[y].Get());
}
}
// Play with it...
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kStringCount; ++y) {
// Test string_compareto x y
size_t result = Invoke3(reinterpret_cast<size_t>(s[x].Get()),
reinterpret_cast<size_t>(s[y].Get()), 0U,
reinterpret_cast<uintptr_t>(&art_quick_string_compareto), self);
EXPECT_FALSE(self->IsExceptionPending());
// The result is a 32b signed integer
union {
size_t r;
int32_t i;
} conv;
conv.r = result;
int32_t e = expected[x][y];
EXPECT_TRUE(e == 0 ? conv.i == 0 : true) << "x=" << c[x] << " y=" << c[y] << " res=" <<
conv.r;
EXPECT_TRUE(e < 0 ? conv.i < 0 : true) << "x=" << c[x] << " y=" << c[y] << " res=" <<
conv.r;
EXPECT_TRUE(e > 0 ? conv.i > 0 : true) << "x=" << c[x] << " y=" << c[y] << " res=" <<
conv.r;
}
}
// TODO: Deallocate things.
// Tests done.
#else
LOG(INFO) << "Skipping string_compareto as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping string_compareto as I don't know how to do that on " << kRuntimeISA <<
std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set32_static(void);
extern "C" void art_quick_get32_static(void);
#endif
static void GetSet32Static(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
constexpr size_t num_values = 7;
uint32_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
static_cast<size_t>(values[i]),
0U,
reinterpret_cast<uintptr_t>(&art_quick_set32_static),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_get32_static),
self,
referrer);
EXPECT_EQ(res, values[i]) << "Iteration " << i;
}
#else
LOG(INFO) << "Skipping set32static as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set32static as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set32_instance(void);
extern "C" void art_quick_get32_instance(void);
#endif
static void GetSet32Instance(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f,
Thread* self, mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
constexpr size_t num_values = 7;
uint32_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
static_cast<size_t>(values[i]),
reinterpret_cast<uintptr_t>(&art_quick_set32_instance),
self,
referrer);
int32_t res = f->Get()->GetInt(obj->Get());
EXPECT_EQ(res, static_cast<int32_t>(values[i])) << "Iteration " << i;
res++;
f->Get()->SetInt<false>(obj->Get(), res);
size_t res2 = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
0U,
reinterpret_cast<uintptr_t>(&art_quick_get32_instance),
self,
referrer);
EXPECT_EQ(res, static_cast<int32_t>(res2));
}
#else
LOG(INFO) << "Skipping set32instance as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set32instance as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set_obj_static(void);
extern "C" void art_quick_get_obj_static(void);
static void set_and_check_static(uint32_t f_idx, mirror::Object* val, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
test->Invoke3WithReferrer(static_cast<size_t>(f_idx),
reinterpret_cast<size_t>(val),
0U,
reinterpret_cast<uintptr_t>(&art_quick_set_obj_static),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>(f_idx),
0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_get_obj_static),
self,
referrer);
EXPECT_EQ(res, reinterpret_cast<size_t>(val)) << "Value " << val;
}
#endif
static void GetSetObjStatic(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
set_and_check_static((*f)->GetDexFieldIndex(), nullptr, self, referrer, test);
// Allocate a string object for simplicity.
mirror::String* str = mirror::String::AllocFromModifiedUtf8(self, "Test");
set_and_check_static((*f)->GetDexFieldIndex(), str, self, referrer, test);
set_and_check_static((*f)->GetDexFieldIndex(), nullptr, self, referrer, test);
#else
LOG(INFO) << "Skipping setObjstatic as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping setObjstatic as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_set_obj_instance(void);
extern "C" void art_quick_get_obj_instance(void);
static void set_and_check_instance(Handle<mirror::ArtField>* f, mirror::Object* trg,
mirror::Object* val, Thread* self, mirror::ArtMethod* referrer,
StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(trg),
reinterpret_cast<size_t>(val),
reinterpret_cast<uintptr_t>(&art_quick_set_obj_instance),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(trg),
0U,
reinterpret_cast<uintptr_t>(&art_quick_get_obj_instance),
self,
referrer);
EXPECT_EQ(res, reinterpret_cast<size_t>(val)) << "Value " << val;
EXPECT_EQ(val, f->Get()->GetObj(trg));
}
#endif
static void GetSetObjInstance(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f,
Thread* self, mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
set_and_check_instance(f, obj->Get(), nullptr, self, referrer, test);
// Allocate a string object for simplicity.
mirror::String* str = mirror::String::AllocFromModifiedUtf8(self, "Test");
set_and_check_instance(f, obj->Get(), str, self, referrer, test);
set_and_check_instance(f, obj->Get(), nullptr, self, referrer, test);
#else
LOG(INFO) << "Skipping setObjinstance as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping setObjinstance as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
// TODO: Complete these tests for 32b architectures.
#if defined(__x86_64__) || defined(__aarch64__)
extern "C" void art_quick_set64_static(void);
extern "C" void art_quick_get64_static(void);
#endif
static void GetSet64Static(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f, Thread* self,
mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__x86_64__) || defined(__aarch64__)
constexpr size_t num_values = 8;
uint64_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF, 0xFFFFFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3UWithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
values[i],
reinterpret_cast<uintptr_t>(&art_quick_set64_static),
self,
referrer);
size_t res = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
0U, 0U,
reinterpret_cast<uintptr_t>(&art_quick_get64_static),
self,
referrer);
EXPECT_EQ(res, values[i]) << "Iteration " << i;
}
#else
LOG(INFO) << "Skipping set64static as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set64static as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__x86_64__) || defined(__aarch64__)
extern "C" void art_quick_set64_instance(void);
extern "C" void art_quick_get64_instance(void);
#endif
static void GetSet64Instance(Handle<mirror::Object>* obj, Handle<mirror::ArtField>* f,
Thread* self, mirror::ArtMethod* referrer, StubTest* test)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__x86_64__) || defined(__aarch64__)
constexpr size_t num_values = 8;
uint64_t values[num_values] = { 0, 1, 2, 255, 32768, 1000000, 0xFFFFFFFF, 0xFFFFFFFFFFFF };
for (size_t i = 0; i < num_values; ++i) {
test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
static_cast<size_t>(values[i]),
reinterpret_cast<uintptr_t>(&art_quick_set64_instance),
self,
referrer);
int64_t res = f->Get()->GetLong(obj->Get());
EXPECT_EQ(res, static_cast<int64_t>(values[i])) << "Iteration " << i;
res++;
f->Get()->SetLong<false>(obj->Get(), res);
size_t res2 = test->Invoke3WithReferrer(static_cast<size_t>((*f)->GetDexFieldIndex()),
reinterpret_cast<size_t>(obj->Get()),
0U,
reinterpret_cast<uintptr_t>(&art_quick_get64_instance),
self,
referrer);
EXPECT_EQ(res, static_cast<int64_t>(res2));
}
#else
LOG(INFO) << "Skipping set64instance as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping set64instance as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
static void TestFields(Thread* self, StubTest* test, Primitive::Type test_type) {
// garbage is created during ClassLinker::Init
JNIEnv* env = Thread::Current()->GetJniEnv();
jclass jc = env->FindClass("AllFields");
CHECK(jc != NULL);
jobject o = env->AllocObject(jc);
CHECK(o != NULL);
ScopedObjectAccess soa(self);
StackHandleScope<5> hs(self);
Handle<mirror::Object> obj(hs.NewHandle(soa.Decode<mirror::Object*>(o)));
Handle<mirror::Class> c(hs.NewHandle(obj->GetClass()));
// Need a method as a referrer
Handle<mirror::ArtMethod> m(hs.NewHandle(c->GetDirectMethod(0)));
// Play with it...
// Static fields.
{
Handle<mirror::ObjectArray<mirror::ArtField>> fields(hs.NewHandle(c.Get()->GetSFields()));
int32_t num_fields = fields->GetLength();
for (int32_t i = 0; i < num_fields; ++i) {
StackHandleScope<1> hs(self);
Handle<mirror::ArtField> f(hs.NewHandle(fields->Get(i)));
Primitive::Type type = f->GetTypeAsPrimitiveType();
switch (type) {
case Primitive::Type::kPrimInt:
if (test_type == type) {
GetSet32Static(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimLong:
if (test_type == type) {
GetSet64Static(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimNot:
// Don't try array.
if (test_type == type && f->GetTypeDescriptor()[0] != '[') {
GetSetObjStatic(&obj, &f, self, m.Get(), test);
}
break;
default:
break; // Skip.
}
}
}
// Instance fields.
{
Handle<mirror::ObjectArray<mirror::ArtField>> fields(hs.NewHandle(c.Get()->GetIFields()));
int32_t num_fields = fields->GetLength();
for (int32_t i = 0; i < num_fields; ++i) {
StackHandleScope<1> hs(self);
Handle<mirror::ArtField> f(hs.NewHandle(fields->Get(i)));
Primitive::Type type = f->GetTypeAsPrimitiveType();
switch (type) {
case Primitive::Type::kPrimInt:
if (test_type == type) {
GetSet32Instance(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimLong:
if (test_type == type) {
GetSet64Instance(&obj, &f, self, m.Get(), test);
}
break;
case Primitive::Type::kPrimNot:
// Don't try array.
if (test_type == type && f->GetTypeDescriptor()[0] != '[') {
GetSetObjInstance(&obj, &f, self, m.Get(), test);
}
break;
default:
break; // Skip.
}
}
}
// TODO: Deallocate things.
}
TEST_F(StubTest, Fields32) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
self->TransitionFromSuspendedToRunnable();
LoadDex("AllFields");
bool started = runtime_->Start();
CHECK(started);
TestFields(self, this, Primitive::Type::kPrimInt);
}
TEST_F(StubTest, FieldsObj) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
self->TransitionFromSuspendedToRunnable();
LoadDex("AllFields");
bool started = runtime_->Start();
CHECK(started);
TestFields(self, this, Primitive::Type::kPrimNot);
}
TEST_F(StubTest, Fields64) {
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
self->TransitionFromSuspendedToRunnable();
LoadDex("AllFields");
bool started = runtime_->Start();
CHECK(started);
TestFields(self, this, Primitive::Type::kPrimLong);
}
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
extern "C" void art_quick_imt_conflict_trampoline(void);
#endif
TEST_F(StubTest, IMT) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__x86_64__)
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
StackHandleScope<7> hs(self);
JNIEnv* env = Thread::Current()->GetJniEnv();
// ArrayList
// Load ArrayList and used methods (JNI).
jclass arraylist_jclass = env->FindClass("java/util/ArrayList");
ASSERT_NE(nullptr, arraylist_jclass);
jmethodID arraylist_constructor = env->GetMethodID(arraylist_jclass, "<init>", "()V");
ASSERT_NE(nullptr, arraylist_constructor);
jmethodID contains_jmethod = env->GetMethodID(arraylist_jclass, "contains", "(Ljava/lang/Object;)Z");
ASSERT_NE(nullptr, contains_jmethod);
jmethodID add_jmethod = env->GetMethodID(arraylist_jclass, "add", "(Ljava/lang/Object;)Z");
ASSERT_NE(nullptr, add_jmethod);
// Get mirror representation.
Handle<mirror::ArtMethod> contains_amethod(hs.NewHandle(soa.DecodeMethod(contains_jmethod)));
// Patch up ArrayList.contains.
if (contains_amethod.Get()->GetEntryPointFromQuickCompiledCode() == nullptr) {
contains_amethod.Get()->SetEntryPointFromQuickCompiledCode(reinterpret_cast<void*>(
GetTlsPtr(self)->quick_entrypoints.pQuickToInterpreterBridge));
}
// List
// Load List and used methods (JNI).
jclass list_jclass = env->FindClass("java/util/List");
ASSERT_NE(nullptr, list_jclass);
jmethodID inf_contains_jmethod = env->GetMethodID(list_jclass, "contains", "(Ljava/lang/Object;)Z");
ASSERT_NE(nullptr, inf_contains_jmethod);
// Get mirror representation.
Handle<mirror::ArtMethod> inf_contains(hs.NewHandle(soa.DecodeMethod(inf_contains_jmethod)));
// Object
jclass obj_jclass = env->FindClass("java/lang/Object");
ASSERT_NE(nullptr, obj_jclass);
jmethodID obj_constructor = env->GetMethodID(obj_jclass, "<init>", "()V");
ASSERT_NE(nullptr, obj_constructor);
// Sanity check: check that there is a conflict for List.contains in ArrayList.
mirror::Class* arraylist_class = soa.Decode<mirror::Class*>(arraylist_jclass);
mirror::ArtMethod* m = arraylist_class->GetImTable()->Get(
inf_contains->GetDexMethodIndex() % ClassLinker::kImtSize);
if (!m->IsImtConflictMethod()) {
LOG(WARNING) << "Test is meaningless, no IMT conflict in setup: " <<
PrettyMethod(m, true);
LOG(WARNING) << "Please update StubTest.IMT.";
return;
}
// Create instances.
jobject jarray_list = env->NewObject(arraylist_jclass, arraylist_constructor);
ASSERT_NE(nullptr, jarray_list);
Handle<mirror::Object> array_list(hs.NewHandle(soa.Decode<mirror::Object*>(jarray_list)));
jobject jobj = env->NewObject(obj_jclass, obj_constructor);
ASSERT_NE(nullptr, jobj);
Handle<mirror::Object> obj(hs.NewHandle(soa.Decode<mirror::Object*>(jobj)));
// Invoke.
size_t result =
Invoke3WithReferrerAndHidden(0U, reinterpret_cast<size_t>(array_list.Get()),
reinterpret_cast<size_t>(obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_imt_conflict_trampoline),
self, contains_amethod.Get(),
static_cast<size_t>(inf_contains.Get()->GetDexMethodIndex()));
ASSERT_FALSE(self->IsExceptionPending());
EXPECT_EQ(static_cast<size_t>(JNI_FALSE), result);
// Add object.
env->CallBooleanMethod(jarray_list, add_jmethod, jobj);
ASSERT_FALSE(self->IsExceptionPending()) << PrettyTypeOf(self->GetException(nullptr));
// Invoke again.
result = Invoke3WithReferrerAndHidden(0U, reinterpret_cast<size_t>(array_list.Get()),
reinterpret_cast<size_t>(obj.Get()),
reinterpret_cast<uintptr_t>(&art_quick_imt_conflict_trampoline),
self, contains_amethod.Get(),
static_cast<size_t>(inf_contains.Get()->GetDexMethodIndex()));
ASSERT_FALSE(self->IsExceptionPending());
EXPECT_EQ(static_cast<size_t>(JNI_TRUE), result);
#else
LOG(INFO) << "Skipping imt as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping imt as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
#if defined(__arm__) || defined(__aarch64__)
extern "C" void art_quick_indexof(void);
#endif
TEST_F(StubTest, StringIndexOf) {
#if defined(__arm__) || defined(__aarch64__)
TEST_DISABLED_FOR_HEAP_REFERENCE_POISONING();
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
// garbage is created during ClassLinker::Init
// Create some strings
// Use array so we can index into it and use a matrix for expected results
// Setup: The first half is standard. The second half uses a non-zero offset.
// TODO: Shared backing arrays.
static constexpr size_t kStringCount = 7;
const char* c_str[kStringCount] = { "", "a", "ba", "cba", "dcba", "edcba", "asdfghjkl" };
static constexpr size_t kCharCount = 5;
const char c_char[kCharCount] = { 'a', 'b', 'c', 'd', 'e' };
StackHandleScope<kStringCount> hs(self);
Handle<mirror::String> s[kStringCount];
for (size_t i = 0; i < kStringCount; ++i) {
s[i] = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), c_str[i]));
}
// Matrix of expectations. First component is first parameter. Note we only check against the
// sign, not the value. As we are testing random offsets, we need to compute this and need to
// rely on String::CompareTo being correct.
static constexpr size_t kMaxLen = 9;
DCHECK_LE(strlen(c_str[kStringCount-1]), kMaxLen) << "Please fix the indexof test.";
// Last dimension: start, offset by 1.
int32_t expected[kStringCount][kCharCount][kMaxLen + 3];
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kCharCount; ++y) {
for (size_t z = 0; z <= kMaxLen + 2; ++z) {
expected[x][y][z] = s[x]->FastIndexOf(c_char[y], static_cast<int32_t>(z) - 1);
}
}
}
// Play with it...
for (size_t x = 0; x < kStringCount; ++x) {
for (size_t y = 0; y < kCharCount; ++y) {
for (size_t z = 0; z <= kMaxLen + 2; ++z) {
int32_t start = static_cast<int32_t>(z) - 1;
// Test string_compareto x y
size_t result = Invoke3(reinterpret_cast<size_t>(s[x].Get()), c_char[y], start,
reinterpret_cast<uintptr_t>(&art_quick_indexof), self);
EXPECT_FALSE(self->IsExceptionPending());
// The result is a 32b signed integer
union {
size_t r;
int32_t i;
} conv;
conv.r = result;
EXPECT_EQ(expected[x][y][z], conv.i) << "Wrong result for " << c_str[x] << " / " <<
c_char[y] << " @ " << start;
}
}
}
// TODO: Deallocate things.
// Tests done.
#else
LOG(INFO) << "Skipping indexof as I don't know how to do that on " << kRuntimeISA;
// Force-print to std::cout so it's also outside the logcat.
std::cout << "Skipping indexof as I don't know how to do that on " << kRuntimeISA << std::endl;
#endif
}
} // namespace art
|
/* -*- mode: c++; indent-tabs-mode: nil -*- */
/* -------------------------------------------------------------------------
ATS
License: see $ATS_DIR/COPYRIGHT
Author: Ethan Coon
Default base with default implementations of methods for a PK integrated using
BDF.
------------------------------------------------------------------------- */
#include "Teuchos_TimeMonitor.hpp"
#include "BDF1_TI.hh"
#include "pk_bdf_default.hh"
#include "State.hh"
namespace Amanzi {
// -----------------------------------------------------------------------------
// Setup
// -----------------------------------------------------------------------------
void PK_BDF_Default::Setup()
{
// preconditioner assembly
assemble_preconditioner_ = plist_->get<bool>("assemble preconditioner", true);
strongly_coupled_ = plist_->get<bool>("strongly coupled PK", false);
if (!strongly_coupled_) {
Teuchos::ParameterList& bdf_plist = plist_->sublist("time integrator");
// check if continuation method and require continuation parameter
// -- ETC Note this needs fixed if more than one continuation method used
if (bdf_plist.isSublist("continuation parameters")) {
S_->Require<double>("continuation_parameter", Tag(name_), name_);
}
// require data for checkpointing timestep size
S_->Require<double>("dt", Tag(name_), name_);
}
};
// -----------------------------------------------------------------------------
// Initialization of timestepper.
// -----------------------------------------------------------------------------
void PK_BDF_Default::Initialize()
{
if (!strongly_coupled_) {
// initialize the timestep
double dt = plist_->get<double>("initial time step [s]", 1.);
S_->Assign("dt", Tag(name_), name_, dt);
S_->GetRecordW("dt", Tag(name_), name_).set_initialized();
// set up the timestepping algorithm
// -- construct the time integrator
// Note, this is done here and not in setup because solution is not ready in setup
Teuchos::ParameterList& bdf_plist = plist_->sublist("time integrator");
if (!bdf_plist.isSublist("verbose object"))
bdf_plist.set("verbose object", plist_->sublist("verbose object"));
time_stepper_ = Teuchos::rcp(new BDF1_TI<TreeVector,TreeVectorSpace>(*this,
bdf_plist, solution_, S_));
// -- initialize continuation parameter if needed.
if (S_->HasRecord("continuation_parameter", Tag(name_))) {
S_->Assign("continuation_parameter", Tag(name_), name_, (double) 1.);
S_->GetRecordW("continuation_parameter", Tag(name_), name_).set_initialized();
}
// -- initialize time derivative
auto solution_dot = Teuchos::rcp(new TreeVector(*solution_));
solution_dot->PutScalar(0.0);
// -- set initial state
time_stepper_->SetInitialState(S_->get_time(), solution_, solution_dot);
}
};
void PK_BDF_Default::ResetTimeStepper(double time)
{
// -- initialize time derivative
auto solution_dot = Teuchos::rcp(new TreeVector(*solution_));
solution_dot->PutScalar(0.0);
// -- set initial state
time_stepper_->SetInitialState(time, solution_, solution_dot);
return;
}
// -----------------------------------------------------------------------------
// Initialization of timestepper.
// -----------------------------------------------------------------------------
double PK_BDF_Default::get_dt() {
if (!strongly_coupled_)
return S_->Get<double>("dt", Tag(name_));
else
return -1.;
}
void PK_BDF_Default::set_dt(double dt) {
if (!strongly_coupled_)
S_->Assign("dt", Tag(name_), name_, dt);
}
// -- Commit any secondary (dependent) variables.
void PK_BDF_Default::CommitStep(double t_old, double t_new, const Tag& tag)
{
if (tag == tag_next_) {
double dt = t_new - t_old;
if (time_stepper_ != Teuchos::null) {
if (dt <= 0) {
ResetTimeStepper(t_old);
} else {
time_stepper_->CommitSolution(dt, solution_, true);
}
}
}
}
// -----------------------------------------------------------------------------
// Advance from state S to state S_next at time S.time + dt.
// -----------------------------------------------------------------------------
bool PK_BDF_Default::AdvanceStep(double t_old, double t_new, bool reinit)
{
double dt = t_new - t_old;
Teuchos::OSTab out = vo_->getOSTab();
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "----------------------------------------------------------------" << std::endl
<< "Advancing: t0 = " << S_->get_time(tag_current_)
<< " t1 = " << S_->get_time(tag_next_) << " h = " << dt << std::endl
<< "----------------------------------------------------------------" << std::endl;
State_to_Solution(Tags::NEXT, *solution_);
// take a bdf timestep
// Three dts:
// -- dt is the requested timestep size. It must be less than or equal to...
// -- dt_internal is the max valid dt, and is set by physics/solvers
// -- dt_solver is what the solver wants to do
double dt_internal = S_->Get<double>("dt", Tag(name_));
AMANZI_ASSERT(dt <= dt_internal + 1.e-8); // roundoff
double dt_solver = -1;
bool fail = time_stepper_->TimeStep(dt, dt_solver, solution_);
if (!fail) {
// check step validity
bool valid = ValidStep();
if (valid) {
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "successful advance" << std::endl;
// update the timestep size
if (dt_solver < dt_internal && dt_solver >= dt) {
// We took a smaller step than we recommended, and it worked fine (not
// suprisingly). Likely this was due to constraints from other PKs or
// vis. Do not reduce our recommendation.
} else {
dt_internal = dt_solver;
}
} else {
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "successful advance, but not valid" << std::endl;
time_stepper_->CommitSolution(dt_internal, solution_, valid);
dt_internal = 0.5 * dt_internal;
// when including Valid here, make fail = true refs #110
}
} else {
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "unsuccessful advance" << std::endl;
// take the decreased timestep size
dt_internal = dt_solver;
}
S_->Assign("dt", Tag(name_), name_, dt_internal);
return fail;
};
// update the continuation parameter
void PK_BDF_Default::UpdateContinuationParameter(double lambda)
{
S_->Assign("continuation_parameter", Tag(name_), name_, lambda);
ChangedSolution();
}
} // namespace
removes assertion that I think should be valid, but triggers due to amanzi/amanzi#695
/* -*- mode: c++; indent-tabs-mode: nil -*- */
/* -------------------------------------------------------------------------
ATS
License: see $ATS_DIR/COPYRIGHT
Author: Ethan Coon
Default base with default implementations of methods for a PK integrated using
BDF.
------------------------------------------------------------------------- */
#include "Teuchos_TimeMonitor.hpp"
#include "BDF1_TI.hh"
#include "pk_bdf_default.hh"
#include "State.hh"
namespace Amanzi {
// -----------------------------------------------------------------------------
// Setup
// -----------------------------------------------------------------------------
void PK_BDF_Default::Setup()
{
// preconditioner assembly
assemble_preconditioner_ = plist_->get<bool>("assemble preconditioner", true);
strongly_coupled_ = plist_->get<bool>("strongly coupled PK", false);
if (!strongly_coupled_) {
Teuchos::ParameterList& bdf_plist = plist_->sublist("time integrator");
// check if continuation method and require continuation parameter
// -- ETC Note this needs fixed if more than one continuation method used
if (bdf_plist.isSublist("continuation parameters")) {
S_->Require<double>("continuation_parameter", Tag(name_), name_);
}
// require data for checkpointing timestep size
S_->Require<double>("dt", Tag(name_), name_);
}
};
// -----------------------------------------------------------------------------
// Initialization of timestepper.
// -----------------------------------------------------------------------------
void PK_BDF_Default::Initialize()
{
if (!strongly_coupled_) {
// initialize the timestep
double dt = plist_->get<double>("initial time step [s]", 1.);
S_->Assign("dt", Tag(name_), name_, dt);
S_->GetRecordW("dt", Tag(name_), name_).set_initialized();
// set up the timestepping algorithm
// -- construct the time integrator
// Note, this is done here and not in setup because solution is not ready in setup
Teuchos::ParameterList& bdf_plist = plist_->sublist("time integrator");
if (!bdf_plist.isSublist("verbose object"))
bdf_plist.set("verbose object", plist_->sublist("verbose object"));
time_stepper_ = Teuchos::rcp(new BDF1_TI<TreeVector,TreeVectorSpace>(*this,
bdf_plist, solution_, S_));
// -- initialize continuation parameter if needed.
if (S_->HasRecord("continuation_parameter", Tag(name_))) {
S_->Assign("continuation_parameter", Tag(name_), name_, (double) 1.);
S_->GetRecordW("continuation_parameter", Tag(name_), name_).set_initialized();
}
// -- initialize time derivative
auto solution_dot = Teuchos::rcp(new TreeVector(*solution_));
solution_dot->PutScalar(0.0);
// -- set initial state
time_stepper_->SetInitialState(S_->get_time(), solution_, solution_dot);
}
};
void PK_BDF_Default::ResetTimeStepper(double time)
{
// -- initialize time derivative
auto solution_dot = Teuchos::rcp(new TreeVector(*solution_));
solution_dot->PutScalar(0.0);
// -- set initial state
time_stepper_->SetInitialState(time, solution_, solution_dot);
return;
}
// -----------------------------------------------------------------------------
// Initialization of timestepper.
// -----------------------------------------------------------------------------
double PK_BDF_Default::get_dt() {
if (!strongly_coupled_)
return S_->Get<double>("dt", Tag(name_));
else
return -1.;
}
void PK_BDF_Default::set_dt(double dt) {
if (!strongly_coupled_)
S_->Assign("dt", Tag(name_), name_, dt);
}
// -- Commit any secondary (dependent) variables.
void PK_BDF_Default::CommitStep(double t_old, double t_new, const Tag& tag)
{
if (tag == tag_next_) {
double dt = t_new - t_old;
if (time_stepper_ != Teuchos::null) {
if (dt <= 0) {
ResetTimeStepper(t_old);
} else {
time_stepper_->CommitSolution(dt, solution_, true);
}
}
}
}
// -----------------------------------------------------------------------------
// Advance from state S to state S_next at time S.time + dt.
// -----------------------------------------------------------------------------
bool PK_BDF_Default::AdvanceStep(double t_old, double t_new, bool reinit)
{
double dt = t_new - t_old;
Teuchos::OSTab out = vo_->getOSTab();
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "----------------------------------------------------------------" << std::endl
<< "Advancing: t0 = " << S_->get_time(tag_current_)
<< " t1 = " << S_->get_time(tag_next_) << " h = " << dt << std::endl
<< "----------------------------------------------------------------" << std::endl;
State_to_Solution(Tags::NEXT, *solution_);
// take a bdf timestep
// Three dts:
// -- dt is the requested timestep size. It must be less than or equal to...
// -- dt_internal is the max valid dt, and is set by physics/solvers
// -- dt_solver is what the solver wants to do
double dt_internal = S_->Get<double>("dt", Tag(name_));
// Note, the fact that this is triggering an assertion on old old runs
// indicates that there may be a long-standing bug in TimeStepController.
// See Ticket amanzi#685. So for now, we turn this off to get tests to pass.
// --ETC
//AMANZI_ASSERT(dt <= dt_internal + 1.e-8); // roundoff
double dt_solver = -1;
bool fail = time_stepper_->TimeStep(dt, dt_solver, solution_);
if (!fail) {
// check step validity
bool valid = ValidStep();
if (valid) {
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "successful advance" << std::endl;
// update the timestep size
if (dt_solver < dt_internal && dt_solver >= dt) {
// We took a smaller step than we recommended, and it worked fine (not
// suprisingly). Likely this was due to constraints from other PKs or
// vis. Do not reduce our recommendation.
} else {
dt_internal = dt_solver;
}
} else {
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "successful advance, but not valid" << std::endl;
time_stepper_->CommitSolution(dt_internal, solution_, valid);
dt_internal = 0.5 * dt_internal;
// when including Valid here, make fail = true refs #110
}
} else {
if (vo_->os_OK(Teuchos::VERB_LOW))
*vo_->os() << "unsuccessful advance" << std::endl;
// take the decreased timestep size
dt_internal = dt_solver;
}
S_->Assign("dt", Tag(name_), name_, dt_internal);
return fail;
};
// update the continuation parameter
void PK_BDF_Default::UpdateContinuationParameter(double lambda)
{
S_->Assign("continuation_parameter", Tag(name_), name_, lambda);
ChangedSolution();
}
} // namespace
|
#include "RConfigure.h" // R__USE_IMT
#include "ROOT/RDF/RActionBase.hxx"
#include "ROOT/RDF/RCustomColumnBase.hxx"
#include "ROOT/RDF/RFilterBase.hxx"
#include "ROOT/RDF/RLoopManager.hxx"
#include "ROOT/RDF/RRangeBase.hxx"
#include "ROOT/RDF/RSlotStack.hxx"
#include "RtypesCore.h" // Long64_t
#include "TBranchElement.h"
#include "TBranchObject.h"
#include "TEntryList.h"
#include "TError.h"
#include "TFriendElement.h"
#include "TInterpreter.h"
#include "TROOT.h" // IsImplicitMTEnabled
#include "TTreeReader.h"
#ifdef R__USE_IMT
#include "ROOT/TThreadExecutor.hxx"
#include "ROOT/TTreeProcessorMT.hxx"
#endif
#include <atomic>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
using namespace ROOT::Detail::RDF;
using namespace ROOT::Internal::RDF;
bool ContainsLeaf(const std::set<TLeaf *> &leaves, TLeaf *leaf)
{
return (leaves.find(leaf) != leaves.end());
}
///////////////////////////////////////////////////////////////////////////////
/// This overload does not perform any check on the duplicates.
/// It is used for TBranch objects.
void UpdateList(std::set<std::string> &bNamesReg, ColumnNames_t &bNames, const std::string &branchName,
const std::string &friendName)
{
if (!friendName.empty()) {
// In case of a friend tree, users might prepend its name/alias to the branch names
const auto friendBName = friendName + "." + branchName;
if (bNamesReg.insert(friendBName).second)
bNames.push_back(friendBName);
}
if (bNamesReg.insert(branchName).second)
bNames.push_back(branchName);
}
///////////////////////////////////////////////////////////////////////////////
/// This overloads makes sure that the TLeaf has not been already inserted.
void UpdateList(std::set<std::string> &bNamesReg, ColumnNames_t &bNames, const std::string &branchName,
const std::string &friendName, std::set<TLeaf *> &foundLeaves, TLeaf *leaf, bool allowDuplicates)
{
const bool canAdd = allowDuplicates ? true : !ContainsLeaf(foundLeaves, leaf);
if (!canAdd) {
return;
}
UpdateList(bNamesReg, bNames, branchName, friendName);
foundLeaves.insert(leaf);
}
void ExploreBranch(TTree &t, std::set<std::string> &bNamesReg, ColumnNames_t &bNames, TBranch *b, std::string prefix,
std::string &friendName)
{
for (auto sb : *b->GetListOfBranches()) {
TBranch *subBranch = static_cast<TBranch *>(sb);
auto subBranchName = std::string(subBranch->GetName());
auto fullName = prefix + subBranchName;
std::string newPrefix;
if (!prefix.empty())
newPrefix = fullName + ".";
ExploreBranch(t, bNamesReg, bNames, subBranch, newPrefix, friendName);
if (t.GetBranch(fullName.c_str())) {
UpdateList(bNamesReg, bNames, fullName, friendName);
} else if (t.GetBranch(subBranchName.c_str())) {
UpdateList(bNamesReg, bNames, subBranchName, friendName);
}
}
}
void GetBranchNamesImpl(TTree &t, std::set<std::string> &bNamesReg, ColumnNames_t &bNames,
std::set<TTree *> &analysedTrees, std::string &friendName, bool allowDuplicates)
{
std::set<TLeaf *> foundLeaves;
if (!analysedTrees.insert(&t).second) {
return;
}
const auto branches = t.GetListOfBranches();
// Getting the branches here triggered the read of the first file of the chain if t is a chain.
// We check if a tree has been successfully read, otherwise we throw (see ROOT-9984) to avoid further
// operations
if (!t.GetTree()) {
std::string err("GetBranchNames: error in opening the tree ");
err += t.GetName();
throw std::runtime_error(err);
}
if (branches) {
for (auto b : *branches) {
TBranch *branch = static_cast<TBranch *>(b);
const auto branchName = std::string(branch->GetName());
if (branch->IsA() == TBranch::Class()) {
// Leaf list
auto listOfLeaves = branch->GetListOfLeaves();
if (listOfLeaves->GetEntries() == 1) {
auto leaf = static_cast<TLeaf *>(listOfLeaves->At(0));
const auto leafName = std::string(leaf->GetName());
if (leafName == branchName) {
UpdateList(bNamesReg, bNames, branchName, friendName, foundLeaves, leaf, allowDuplicates);
}
}
for (auto leaf : *listOfLeaves) {
auto castLeaf = static_cast<TLeaf *>(leaf);
const auto leafName = std::string(leaf->GetName());
const auto fullName = branchName + "." + leafName;
UpdateList(bNamesReg, bNames, fullName, friendName, foundLeaves, castLeaf, allowDuplicates);
}
} else if (branch->IsA() == TBranchObject::Class()) {
// TBranchObject
ExploreBranch(t, bNamesReg, bNames, branch, branchName + ".", friendName);
UpdateList(bNamesReg, bNames, branchName, friendName);
} else {
// TBranchElement
// Check if there is explicit or implicit dot in the name
bool dotIsImplied = false;
auto be = dynamic_cast<TBranchElement *>(b);
if (!be)
throw std::runtime_error("GetBranchNames: unsupported branch type");
// TClonesArray (3) and STL collection (4)
if (be->GetType() == 3 || be->GetType() == 4)
dotIsImplied = true;
if (dotIsImplied || branchName.back() == '.')
ExploreBranch(t, bNamesReg, bNames, branch, "", friendName);
else
ExploreBranch(t, bNamesReg, bNames, branch, branchName + ".", friendName);
UpdateList(bNamesReg, bNames, branchName, friendName);
}
}
}
auto friendTrees = t.GetListOfFriends();
if (!friendTrees)
return;
for (auto friendTreeObj : *friendTrees) {
auto friendTree = ((TFriendElement *)friendTreeObj)->GetTree();
std::string frName;
auto alias = t.GetFriendAlias(friendTree);
if (alias != nullptr)
frName = std::string(alias);
else
frName = std::string(friendTree->GetName());
GetBranchNamesImpl(*friendTree, bNamesReg, bNames, analysedTrees, frName, allowDuplicates);
}
}
///////////////////////////////////////////////////////////////////////////////
/// Get all the branches names, including the ones of the friend trees
ColumnNames_t ROOT::Internal::RDF::GetBranchNames(TTree &t, bool allowDuplicates)
{
std::set<std::string> bNamesSet;
ColumnNames_t bNames;
std::set<TTree *> analysedTrees;
std::string emptyFrName = "";
GetBranchNamesImpl(t, bNamesSet, bNames, analysedTrees, emptyFrName, allowDuplicates);
return bNames;
}
RLoopManager::RLoopManager(TTree *tree, const ColumnNames_t &defaultBranches)
: fTree(std::shared_ptr<TTree>(tree, [](TTree *) {})), fDefaultColumns(defaultBranches),
fNSlots(RDFInternal::GetNSlots()),
fLoopType(ROOT::IsImplicitMTEnabled() ? ELoopType::kROOTFilesMT : ELoopType::kROOTFiles)
{
}
RLoopManager::RLoopManager(ULong64_t nEmptyEntries)
: fNEmptyEntries(nEmptyEntries), fNSlots(RDFInternal::GetNSlots()),
fLoopType(ROOT::IsImplicitMTEnabled() ? ELoopType::kNoFilesMT : ELoopType::kNoFiles)
{
}
RLoopManager::RLoopManager(std::unique_ptr<RDataSource> ds, const ColumnNames_t &defaultBranches)
: fDefaultColumns(defaultBranches), fNSlots(RDFInternal::GetNSlots()),
fLoopType(ROOT::IsImplicitMTEnabled() ? ELoopType::kDataSourceMT : ELoopType::kDataSource),
fDataSource(std::move(ds))
{
fDataSource->SetNSlots(fNSlots);
}
// ROOT-9559: we cannot handle indexed friends
void RLoopManager::CheckIndexedFriends()
{
auto friends = fTree->GetListOfFriends();
if (!friends)
return;
for (auto friendElObj : *friends) {
auto friendEl = static_cast<TFriendElement *>(friendElObj);
auto friendTree = friendEl->GetTree();
if (friendTree && friendTree->GetTreeIndex()) {
std::string err = fTree->GetName();
err += " has a friend, \"";
err += friendTree->GetName();
err += "\", which has an index. This is not supported.";
throw std::runtime_error(err);
}
}
}
/// Run event loop with no source files, in parallel.
void RLoopManager::RunEmptySourceMT()
{
#ifdef R__USE_IMT
RSlotStack slotStack(fNSlots);
// Working with an empty tree.
// Evenly partition the entries according to fNSlots. Produce around 2 tasks per slot.
const auto nEntriesPerSlot = fNEmptyEntries / (fNSlots * 2);
auto remainder = fNEmptyEntries % (fNSlots * 2);
std::vector<std::pair<ULong64_t, ULong64_t>> entryRanges;
ULong64_t start = 0;
while (start < fNEmptyEntries) {
ULong64_t end = start + nEntriesPerSlot;
if (remainder > 0) {
++end;
--remainder;
}
entryRanges.emplace_back(start, end);
start = end;
}
// Each task will generate a subrange of entries
auto genFunction = [this, &slotStack](const std::pair<ULong64_t, ULong64_t> &range) {
auto slot = slotStack.GetSlot();
InitNodeSlots(nullptr, slot);
for (auto currEntry = range.first; currEntry < range.second; ++currEntry) {
RunAndCheckFilters(slot, currEntry);
}
CleanUpTask(slot);
slotStack.ReturnSlot(slot);
};
ROOT::TThreadExecutor pool;
pool.Foreach(genFunction, entryRanges);
#endif // not implemented otherwise
}
/// Run event loop with no source files, in sequence.
void RLoopManager::RunEmptySource()
{
InitNodeSlots(nullptr, 0);
for (ULong64_t currEntry = 0; currEntry < fNEmptyEntries && fNStopsReceived < fNChildren; ++currEntry) {
RunAndCheckFilters(0, currEntry);
}
CleanUpTask(0u);
}
/// Run event loop over one or multiple ROOT files, in parallel.
void RLoopManager::RunTreeProcessorMT()
{
#ifdef R__USE_IMT
CheckIndexedFriends();
RSlotStack slotStack(fNSlots);
const auto &entryList = fTree->GetEntryList() ? *fTree->GetEntryList() : TEntryList();
auto tp = std::make_unique<ROOT::TTreeProcessorMT>(*fTree, entryList);
std::atomic<ULong64_t> entryCount(0ull);
tp->Process([this, &slotStack, &entryCount](TTreeReader &r) -> void {
auto slot = slotStack.GetSlot();
InitNodeSlots(&r, slot);
const auto entryRange = r.GetEntriesRange(); // we trust TTreeProcessorMT to call SetEntriesRange
const auto nEntries = entryRange.second - entryRange.first;
auto count = entryCount.fetch_add(nEntries);
// recursive call to check filters and conditionally execute actions
while (r.Next()) {
RunAndCheckFilters(slot, count++);
}
CleanUpTask(slot);
slotStack.ReturnSlot(slot);
});
#endif // no-op otherwise (will not be called)
}
/// Run event loop over one or multiple ROOT files, in sequence.
void RLoopManager::RunTreeReader()
{
CheckIndexedFriends();
TTreeReader r(fTree.get(), fTree->GetEntryList());
if (0 == fTree->GetEntriesFast())
return;
InitNodeSlots(&r, 0);
// recursive call to check filters and conditionally execute actions
// in the non-MT case processing can be stopped early by ranges, hence the check on fNStopsReceived
while (r.Next() && fNStopsReceived < fNChildren) {
RunAndCheckFilters(0, r.GetCurrentEntry());
}
CleanUpTask(0u);
}
/// Run event loop over data accessed through a DataSource, in sequence.
void RLoopManager::RunDataSource()
{
R__ASSERT(fDataSource != nullptr);
fDataSource->Initialise();
auto ranges = fDataSource->GetEntryRanges();
while (!ranges.empty()) {
InitNodeSlots(nullptr, 0u);
fDataSource->InitSlot(0u, 0ull);
for (const auto &range : ranges) {
auto end = range.second;
for (auto entry = range.first; entry < end; ++entry) {
if (fDataSource->SetEntry(0u, entry)) {
RunAndCheckFilters(0u, entry);
}
}
}
CleanUpTask(0u);
fDataSource->FinaliseSlot(0u);
ranges = fDataSource->GetEntryRanges();
}
fDataSource->Finalise();
}
/// Run event loop over data accessed through a DataSource, in parallel.
void RLoopManager::RunDataSourceMT()
{
#ifdef R__USE_IMT
R__ASSERT(fDataSource != nullptr);
RSlotStack slotStack(fNSlots);
ROOT::TThreadExecutor pool;
// Each task works on a subrange of entries
auto runOnRange = [this, &slotStack](const std::pair<ULong64_t, ULong64_t> &range) {
const auto slot = slotStack.GetSlot();
InitNodeSlots(nullptr, slot);
fDataSource->InitSlot(slot, range.first);
const auto end = range.second;
for (auto entry = range.first; entry < end; ++entry) {
if (fDataSource->SetEntry(slot, entry)) {
RunAndCheckFilters(slot, entry);
}
}
CleanUpTask(slot);
fDataSource->FinaliseSlot(slot);
slotStack.ReturnSlot(slot);
};
fDataSource->Initialise();
auto ranges = fDataSource->GetEntryRanges();
while (!ranges.empty()) {
pool.Foreach(runOnRange, ranges);
ranges = fDataSource->GetEntryRanges();
}
fDataSource->Finalise();
#endif // not implemented otherwise (never called)
}
/// Execute actions and make sure named filters are called for each event.
/// Named filters must be called even if the analysis logic would not require it, lest they report confusing results.
void RLoopManager::RunAndCheckFilters(unsigned int slot, Long64_t entry)
{
for (auto &actionPtr : fBookedActions)
actionPtr->Run(slot, entry);
for (auto &namedFilterPtr : fBookedNamedFilters)
namedFilterPtr->CheckFilters(slot, entry);
for (auto &callback : fCallbacks)
callback(slot);
}
/// Build TTreeReaderValues for all nodes
/// This method loops over all filters, actions and other booked objects and
/// calls their `InitRDFValues` methods. It is called once per node per slot, before
/// running the event loop. It also informs each node of the TTreeReader that
/// a particular slot will be using.
void RLoopManager::InitNodeSlots(TTreeReader *r, unsigned int slot)
{
for (auto &ptr : fBookedActions)
ptr->InitSlot(r, slot);
for (auto &ptr : fBookedFilters)
ptr->InitSlot(r, slot);
for (auto &callback : fCallbacksOnce)
callback(slot);
}
/// Initialize all nodes of the functional graph before running the event loop.
/// This method is called once per event-loop and performs generic initialization
/// operations that do not depend on the specific processing slot (i.e. operations
/// that are common for all threads).
void RLoopManager::InitNodes()
{
EvalChildrenCounts();
for (auto column : fCustomColumns)
column->InitNode();
for (auto &filter : fBookedFilters)
filter->InitNode();
for (auto &range : fBookedRanges)
range->InitNode();
for (auto &ptr : fBookedActions)
ptr->Initialize();
}
/// Perform clean-up operations. To be called at the end of each event loop.
void RLoopManager::CleanUpNodes()
{
fMustRunNamedFilters = false;
// forget RActions and detach TResultProxies
for (auto &ptr : fBookedActions)
ptr->Finalize();
fRunActions.insert(fRunActions.begin(), fBookedActions.begin(), fBookedActions.end());
fBookedActions.clear();
// reset children counts
fNChildren = 0;
fNStopsReceived = 0;
for (auto &ptr : fBookedFilters)
ptr->ResetChildrenCount();
for (auto &ptr : fBookedRanges)
ptr->ResetChildrenCount();
fCallbacks.clear();
fCallbacksOnce.clear();
}
/// Perform clean-up operations. To be called at the end of each task execution.
void RLoopManager::CleanUpTask(unsigned int slot)
{
for (auto &ptr : fBookedActions)
ptr->FinalizeSlot(slot);
for (auto &ptr : fBookedFilters)
ptr->ClearTask(slot);
}
/// Declare to the interpreter type aliases and other entities required by RDF jitted nodes.
/// This method clears the `fToJitDeclare` member variable.
void RLoopManager::JitDeclarations()
{
if (fToJitDeclare.empty())
return;
RDFInternal::InterpreterDeclare(fToJitDeclare);
fToJitDeclare.clear();
}
/// Add RDF nodes that require just-in-time compilation to the computation graph.
/// This method also invokes JitDeclarations() if needed, and clears the `fToJitExec` member variable.
void RLoopManager::Jit()
{
if (fToJitExec.empty())
return;
JitDeclarations();
RDFInternal::InterpreterCalc(fToJitExec, "RLoopManager::Run");
fToJitExec.clear();
}
/// Trigger counting of number of children nodes for each node of the functional graph.
/// This is done once before starting the event loop. Each action sends an `increase children count` signal
/// upstream, which is propagated until RLoopManager. Each time a node receives the signal, in increments its
/// children counter. Each node only propagates the signal once, even if it receives it multiple times.
/// Named filters also send an `increase children count` signal, just like actions, as they always execute during
/// the event loop so the graph branch they belong to must count as active even if it does not end in an action.
void RLoopManager::EvalChildrenCounts()
{
for (auto &actionPtr : fBookedActions)
actionPtr->TriggerChildrenCount();
for (auto &namedFilterPtr : fBookedNamedFilters)
namedFilterPtr->TriggerChildrenCount();
}
unsigned int RLoopManager::GetNextID()
{
static unsigned int id = 0;
++id;
return id;
}
/// Start the event loop with a different mechanism depending on IMT/no IMT, data source/no data source.
/// Also perform a few setup and clean-up operations (jit actions if necessary, clear booked actions after the loop...).
void RLoopManager::Run()
{
Jit();
InitNodes();
switch (fLoopType) {
case ELoopType::kNoFilesMT: RunEmptySourceMT(); break;
case ELoopType::kROOTFilesMT: RunTreeProcessorMT(); break;
case ELoopType::kDataSourceMT: RunDataSourceMT(); break;
case ELoopType::kNoFiles: RunEmptySource(); break;
case ELoopType::kROOTFiles: RunTreeReader(); break;
case ELoopType::kDataSource: RunDataSource(); break;
}
CleanUpNodes();
fNRuns++;
}
/// Return the list of default columns -- empty if none was provided when constructing the RDataFrame
const ColumnNames_t &RLoopManager::GetDefaultColumnNames() const
{
return fDefaultColumns;
}
TTree *RLoopManager::GetTree() const
{
return fTree.get();
}
void RLoopManager::Book(RDFInternal::RActionBase *actionPtr)
{
fBookedActions.emplace_back(actionPtr);
}
void RLoopManager::Deregister(RDFInternal::RActionBase *actionPtr)
{
RDFInternal::Erase(actionPtr, fRunActions);
RDFInternal::Erase(actionPtr, fBookedActions);
}
void RLoopManager::Book(RFilterBase *filterPtr)
{
fBookedFilters.emplace_back(filterPtr);
if (filterPtr->HasName()) {
fBookedNamedFilters.emplace_back(filterPtr);
fMustRunNamedFilters = true;
}
}
void RLoopManager::Deregister(RFilterBase *filterPtr)
{
RDFInternal::Erase(filterPtr, fBookedFilters);
RDFInternal::Erase(filterPtr, fBookedNamedFilters);
}
void RLoopManager::Book(RRangeBase *rangePtr)
{
fBookedRanges.emplace_back(rangePtr);
}
void RLoopManager::Deregister(RRangeBase *rangePtr)
{
RDFInternal::Erase(rangePtr, fBookedRanges);
}
// dummy call, end of recursive chain of calls
bool RLoopManager::CheckFilters(unsigned int, Long64_t)
{
return true;
}
/// Call `FillReport` on all booked filters
void RLoopManager::Report(ROOT::RDF::RCutFlowReport &rep) const
{
for (const auto &fPtr : fBookedNamedFilters)
fPtr->FillReport(rep);
}
void RLoopManager::RegisterCallback(ULong64_t everyNEvents, std::function<void(unsigned int)> &&f)
{
if (everyNEvents == 0ull)
fCallbacksOnce.emplace_back(std::move(f), fNSlots);
else
fCallbacks.emplace_back(everyNEvents, std::move(f), fNSlots);
}
std::vector<std::string> RLoopManager::GetFiltersNames()
{
std::vector<std::string> filters;
for (auto &filter : fBookedFilters) {
auto name = (filter->HasName() ? filter->GetName() : "Unnamed Filter");
filters.push_back(name);
}
return filters;
}
std::vector<RDFInternal::RActionBase *> RLoopManager::GetAllActions()
{
std::vector<RDFInternal::RActionBase *> actions;
actions.insert(actions.begin(), fBookedActions.begin(), fBookedActions.end());
actions.insert(actions.begin(), fRunActions.begin(), fRunActions.end());
return actions;
}
std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode> RLoopManager::GetGraph()
{
std::string name;
if (fDataSource) {
name = fDataSource->GetLabel();
} else if (fTree) {
name = fTree->GetName();
} else {
name = std::to_string(fNEmptyEntries);
}
auto thisNode = std::make_shared<ROOT::Internal::RDF::GraphDrawing::GraphNode>(name);
thisNode->SetRoot();
thisNode->SetCounter(0);
return thisNode;
}
////////////////////////////////////////////////////////////////////////////
/// Return all valid TTree::Branch names (caching results for subsequent calls).
/// Never use fBranchNames directy, always request it through this method.
const ColumnNames_t &RLoopManager::GetBranchNames()
{
if (fValidBranchNames.empty() && fTree) {
fValidBranchNames = RDFInternal::GetBranchNames(*fTree, /*allowRepetitions=*/true);
}
return fValidBranchNames;
}
[DF] Call CleanUpTask even if event loop throws
Even if something within the event loop throws, we still need to call
CleanUpTask to make sure SnapshotHelperMT::FinalizeTask gets called,
to avoid teardown issues due to input and output TTrees of a Snapshot
being deleted concurrently.
#include "RConfigure.h" // R__USE_IMT
#include "ROOT/RDF/RActionBase.hxx"
#include "ROOT/RDF/RCustomColumnBase.hxx"
#include "ROOT/RDF/RFilterBase.hxx"
#include "ROOT/RDF/RLoopManager.hxx"
#include "ROOT/RDF/RRangeBase.hxx"
#include "ROOT/RDF/RSlotStack.hxx"
#include "RtypesCore.h" // Long64_t
#include "TBranchElement.h"
#include "TBranchObject.h"
#include "TEntryList.h"
#include "TFriendElement.h"
#include "TInterpreter.h"
#include "TROOT.h" // IsImplicitMTEnabled
#include "TTreeReader.h"
#ifdef R__USE_IMT
#include "ROOT/TThreadExecutor.hxx"
#include "ROOT/TTreeProcessorMT.hxx"
#endif
#include <atomic>
#include <functional>
#include <memory>
#include <exception>
#include <stdexcept>
#include <string>
#include <vector>
#include <iostream>
using namespace ROOT::Detail::RDF;
using namespace ROOT::Internal::RDF;
bool ContainsLeaf(const std::set<TLeaf *> &leaves, TLeaf *leaf)
{
return (leaves.find(leaf) != leaves.end());
}
///////////////////////////////////////////////////////////////////////////////
/// This overload does not perform any check on the duplicates.
/// It is used for TBranch objects.
void UpdateList(std::set<std::string> &bNamesReg, ColumnNames_t &bNames, const std::string &branchName,
const std::string &friendName)
{
if (!friendName.empty()) {
// In case of a friend tree, users might prepend its name/alias to the branch names
const auto friendBName = friendName + "." + branchName;
if (bNamesReg.insert(friendBName).second)
bNames.push_back(friendBName);
}
if (bNamesReg.insert(branchName).second)
bNames.push_back(branchName);
}
///////////////////////////////////////////////////////////////////////////////
/// This overloads makes sure that the TLeaf has not been already inserted.
void UpdateList(std::set<std::string> &bNamesReg, ColumnNames_t &bNames, const std::string &branchName,
const std::string &friendName, std::set<TLeaf *> &foundLeaves, TLeaf *leaf, bool allowDuplicates)
{
const bool canAdd = allowDuplicates ? true : !ContainsLeaf(foundLeaves, leaf);
if (!canAdd) {
return;
}
UpdateList(bNamesReg, bNames, branchName, friendName);
foundLeaves.insert(leaf);
}
void ExploreBranch(TTree &t, std::set<std::string> &bNamesReg, ColumnNames_t &bNames, TBranch *b, std::string prefix,
std::string &friendName)
{
for (auto sb : *b->GetListOfBranches()) {
TBranch *subBranch = static_cast<TBranch *>(sb);
auto subBranchName = std::string(subBranch->GetName());
auto fullName = prefix + subBranchName;
std::string newPrefix;
if (!prefix.empty())
newPrefix = fullName + ".";
ExploreBranch(t, bNamesReg, bNames, subBranch, newPrefix, friendName);
if (t.GetBranch(fullName.c_str())) {
UpdateList(bNamesReg, bNames, fullName, friendName);
} else if (t.GetBranch(subBranchName.c_str())) {
UpdateList(bNamesReg, bNames, subBranchName, friendName);
}
}
}
void GetBranchNamesImpl(TTree &t, std::set<std::string> &bNamesReg, ColumnNames_t &bNames,
std::set<TTree *> &analysedTrees, std::string &friendName, bool allowDuplicates)
{
std::set<TLeaf *> foundLeaves;
if (!analysedTrees.insert(&t).second) {
return;
}
const auto branches = t.GetListOfBranches();
// Getting the branches here triggered the read of the first file of the chain if t is a chain.
// We check if a tree has been successfully read, otherwise we throw (see ROOT-9984) to avoid further
// operations
if (!t.GetTree()) {
std::string err("GetBranchNames: error in opening the tree ");
err += t.GetName();
throw std::runtime_error(err);
}
if (branches) {
for (auto b : *branches) {
TBranch *branch = static_cast<TBranch *>(b);
const auto branchName = std::string(branch->GetName());
if (branch->IsA() == TBranch::Class()) {
// Leaf list
auto listOfLeaves = branch->GetListOfLeaves();
if (listOfLeaves->GetEntries() == 1) {
auto leaf = static_cast<TLeaf *>(listOfLeaves->At(0));
const auto leafName = std::string(leaf->GetName());
if (leafName == branchName) {
UpdateList(bNamesReg, bNames, branchName, friendName, foundLeaves, leaf, allowDuplicates);
}
}
for (auto leaf : *listOfLeaves) {
auto castLeaf = static_cast<TLeaf *>(leaf);
const auto leafName = std::string(leaf->GetName());
const auto fullName = branchName + "." + leafName;
UpdateList(bNamesReg, bNames, fullName, friendName, foundLeaves, castLeaf, allowDuplicates);
}
} else if (branch->IsA() == TBranchObject::Class()) {
// TBranchObject
ExploreBranch(t, bNamesReg, bNames, branch, branchName + ".", friendName);
UpdateList(bNamesReg, bNames, branchName, friendName);
} else {
// TBranchElement
// Check if there is explicit or implicit dot in the name
bool dotIsImplied = false;
auto be = dynamic_cast<TBranchElement *>(b);
if (!be)
throw std::runtime_error("GetBranchNames: unsupported branch type");
// TClonesArray (3) and STL collection (4)
if (be->GetType() == 3 || be->GetType() == 4)
dotIsImplied = true;
if (dotIsImplied || branchName.back() == '.')
ExploreBranch(t, bNamesReg, bNames, branch, "", friendName);
else
ExploreBranch(t, bNamesReg, bNames, branch, branchName + ".", friendName);
UpdateList(bNamesReg, bNames, branchName, friendName);
}
}
}
auto friendTrees = t.GetListOfFriends();
if (!friendTrees)
return;
for (auto friendTreeObj : *friendTrees) {
auto friendTree = ((TFriendElement *)friendTreeObj)->GetTree();
std::string frName;
auto alias = t.GetFriendAlias(friendTree);
if (alias != nullptr)
frName = std::string(alias);
else
frName = std::string(friendTree->GetName());
GetBranchNamesImpl(*friendTree, bNamesReg, bNames, analysedTrees, frName, allowDuplicates);
}
}
///////////////////////////////////////////////////////////////////////////////
/// Get all the branches names, including the ones of the friend trees
ColumnNames_t ROOT::Internal::RDF::GetBranchNames(TTree &t, bool allowDuplicates)
{
std::set<std::string> bNamesSet;
ColumnNames_t bNames;
std::set<TTree *> analysedTrees;
std::string emptyFrName = "";
GetBranchNamesImpl(t, bNamesSet, bNames, analysedTrees, emptyFrName, allowDuplicates);
return bNames;
}
RLoopManager::RLoopManager(TTree *tree, const ColumnNames_t &defaultBranches)
: fTree(std::shared_ptr<TTree>(tree, [](TTree *) {})), fDefaultColumns(defaultBranches),
fNSlots(RDFInternal::GetNSlots()),
fLoopType(ROOT::IsImplicitMTEnabled() ? ELoopType::kROOTFilesMT : ELoopType::kROOTFiles)
{
}
RLoopManager::RLoopManager(ULong64_t nEmptyEntries)
: fNEmptyEntries(nEmptyEntries), fNSlots(RDFInternal::GetNSlots()),
fLoopType(ROOT::IsImplicitMTEnabled() ? ELoopType::kNoFilesMT : ELoopType::kNoFiles)
{
}
RLoopManager::RLoopManager(std::unique_ptr<RDataSource> ds, const ColumnNames_t &defaultBranches)
: fDefaultColumns(defaultBranches), fNSlots(RDFInternal::GetNSlots()),
fLoopType(ROOT::IsImplicitMTEnabled() ? ELoopType::kDataSourceMT : ELoopType::kDataSource),
fDataSource(std::move(ds))
{
fDataSource->SetNSlots(fNSlots);
}
// ROOT-9559: we cannot handle indexed friends
void RLoopManager::CheckIndexedFriends()
{
auto friends = fTree->GetListOfFriends();
if (!friends)
return;
for (auto friendElObj : *friends) {
auto friendEl = static_cast<TFriendElement *>(friendElObj);
auto friendTree = friendEl->GetTree();
if (friendTree && friendTree->GetTreeIndex()) {
std::string err = fTree->GetName();
err += " has a friend, \"";
err += friendTree->GetName();
err += "\", which has an index. This is not supported.";
throw std::runtime_error(err);
}
}
}
/// Run event loop with no source files, in parallel.
void RLoopManager::RunEmptySourceMT()
{
#ifdef R__USE_IMT
RSlotStack slotStack(fNSlots);
// Working with an empty tree.
// Evenly partition the entries according to fNSlots. Produce around 2 tasks per slot.
const auto nEntriesPerSlot = fNEmptyEntries / (fNSlots * 2);
auto remainder = fNEmptyEntries % (fNSlots * 2);
std::vector<std::pair<ULong64_t, ULong64_t>> entryRanges;
ULong64_t start = 0;
while (start < fNEmptyEntries) {
ULong64_t end = start + nEntriesPerSlot;
if (remainder > 0) {
++end;
--remainder;
}
entryRanges.emplace_back(start, end);
start = end;
}
// Each task will generate a subrange of entries
auto genFunction = [this, &slotStack](const std::pair<ULong64_t, ULong64_t> &range) {
auto slot = slotStack.GetSlot();
InitNodeSlots(nullptr, slot);
try {
for (auto currEntry = range.first; currEntry < range.second; ++currEntry) {
RunAndCheckFilters(slot, currEntry);
}
} catch (...) {
CleanUpTask(slot);
// Error might throw in experiment frameworks like CMSSW
std::cerr << "RDataFrame::Run: event was loop interrupted\n";
throw;
}
CleanUpTask(slot);
slotStack.ReturnSlot(slot);
};
ROOT::TThreadExecutor pool;
pool.Foreach(genFunction, entryRanges);
#endif // not implemented otherwise
}
/// Run event loop with no source files, in sequence.
void RLoopManager::RunEmptySource()
{
InitNodeSlots(nullptr, 0);
try {
for (ULong64_t currEntry = 0; currEntry < fNEmptyEntries && fNStopsReceived < fNChildren; ++currEntry) {
RunAndCheckFilters(0, currEntry);
}
} catch (...) {
CleanUpTask(0u);
std::cerr << "RDataFrame::Run: event was loop interrupted\n";
throw;
}
CleanUpTask(0u);
}
/// Run event loop over one or multiple ROOT files, in parallel.
void RLoopManager::RunTreeProcessorMT()
{
#ifdef R__USE_IMT
CheckIndexedFriends();
RSlotStack slotStack(fNSlots);
const auto &entryList = fTree->GetEntryList() ? *fTree->GetEntryList() : TEntryList();
auto tp = std::make_unique<ROOT::TTreeProcessorMT>(*fTree, entryList);
std::atomic<ULong64_t> entryCount(0ull);
tp->Process([this, &slotStack, &entryCount](TTreeReader &r) -> void {
auto slot = slotStack.GetSlot();
InitNodeSlots(&r, slot);
const auto entryRange = r.GetEntriesRange(); // we trust TTreeProcessorMT to call SetEntriesRange
const auto nEntries = entryRange.second - entryRange.first;
auto count = entryCount.fetch_add(nEntries);
try {
// recursive call to check filters and conditionally execute actions
while (r.Next()) {
RunAndCheckFilters(slot, count++);
}
} catch (...) {
CleanUpTask(slot);
std::cerr << "RDataFrame::Run: event was loop interrupted\n";
throw;
}
CleanUpTask(slot);
slotStack.ReturnSlot(slot);
});
#endif // no-op otherwise (will not be called)
}
/// Run event loop over one or multiple ROOT files, in sequence.
void RLoopManager::RunTreeReader()
{
CheckIndexedFriends();
TTreeReader r(fTree.get(), fTree->GetEntryList());
if (0 == fTree->GetEntriesFast())
return;
InitNodeSlots(&r, 0);
// recursive call to check filters and conditionally execute actions
// in the non-MT case processing can be stopped early by ranges, hence the check on fNStopsReceived
try {
while (r.Next() && fNStopsReceived < fNChildren) {
RunAndCheckFilters(0, r.GetCurrentEntry());
}
} catch (...) {
CleanUpTask(0u);
std::cerr << "RDataFrame::Run: event was loop interrupted\n";
throw;
}
CleanUpTask(0u);
}
/// Run event loop over data accessed through a DataSource, in sequence.
void RLoopManager::RunDataSource()
{
R__ASSERT(fDataSource != nullptr);
fDataSource->Initialise();
auto ranges = fDataSource->GetEntryRanges();
while (!ranges.empty()) {
InitNodeSlots(nullptr, 0u);
fDataSource->InitSlot(0u, 0ull);
try {
for (const auto &range : ranges) {
auto end = range.second;
for (auto entry = range.first; entry < end; ++entry) {
if (fDataSource->SetEntry(0u, entry)) {
RunAndCheckFilters(0u, entry);
}
}
}
} catch (...) {
CleanUpTask(0u);
std::cerr << "RDataFrame::Run: event was loop interrupted\n";
throw;
}
CleanUpTask(0u);
fDataSource->FinaliseSlot(0u);
ranges = fDataSource->GetEntryRanges();
}
fDataSource->Finalise();
}
/// Run event loop over data accessed through a DataSource, in parallel.
void RLoopManager::RunDataSourceMT()
{
#ifdef R__USE_IMT
R__ASSERT(fDataSource != nullptr);
RSlotStack slotStack(fNSlots);
ROOT::TThreadExecutor pool;
// Each task works on a subrange of entries
auto runOnRange = [this, &slotStack](const std::pair<ULong64_t, ULong64_t> &range) {
const auto slot = slotStack.GetSlot();
InitNodeSlots(nullptr, slot);
fDataSource->InitSlot(slot, range.first);
const auto end = range.second;
try {
for (auto entry = range.first; entry < end; ++entry) {
if (fDataSource->SetEntry(slot, entry)) {
RunAndCheckFilters(slot, entry);
}
}
} catch (...) {
CleanUpTask(slot);
std::cerr << "RDataFrame::Run: event was loop interrupted\n";
throw;
}
CleanUpTask(slot);
fDataSource->FinaliseSlot(slot);
slotStack.ReturnSlot(slot);
};
fDataSource->Initialise();
auto ranges = fDataSource->GetEntryRanges();
while (!ranges.empty()) {
pool.Foreach(runOnRange, ranges);
ranges = fDataSource->GetEntryRanges();
}
fDataSource->Finalise();
#endif // not implemented otherwise (never called)
}
/// Execute actions and make sure named filters are called for each event.
/// Named filters must be called even if the analysis logic would not require it, lest they report confusing results.
void RLoopManager::RunAndCheckFilters(unsigned int slot, Long64_t entry)
{
for (auto &actionPtr : fBookedActions)
actionPtr->Run(slot, entry);
for (auto &namedFilterPtr : fBookedNamedFilters)
namedFilterPtr->CheckFilters(slot, entry);
for (auto &callback : fCallbacks)
callback(slot);
}
/// Build TTreeReaderValues for all nodes
/// This method loops over all filters, actions and other booked objects and
/// calls their `InitRDFValues` methods. It is called once per node per slot, before
/// running the event loop. It also informs each node of the TTreeReader that
/// a particular slot will be using.
void RLoopManager::InitNodeSlots(TTreeReader *r, unsigned int slot)
{
for (auto &ptr : fBookedActions)
ptr->InitSlot(r, slot);
for (auto &ptr : fBookedFilters)
ptr->InitSlot(r, slot);
for (auto &callback : fCallbacksOnce)
callback(slot);
}
/// Initialize all nodes of the functional graph before running the event loop.
/// This method is called once per event-loop and performs generic initialization
/// operations that do not depend on the specific processing slot (i.e. operations
/// that are common for all threads).
void RLoopManager::InitNodes()
{
EvalChildrenCounts();
for (auto column : fCustomColumns)
column->InitNode();
for (auto &filter : fBookedFilters)
filter->InitNode();
for (auto &range : fBookedRanges)
range->InitNode();
for (auto &ptr : fBookedActions)
ptr->Initialize();
}
/// Perform clean-up operations. To be called at the end of each event loop.
void RLoopManager::CleanUpNodes()
{
fMustRunNamedFilters = false;
// forget RActions and detach TResultProxies
for (auto &ptr : fBookedActions)
ptr->Finalize();
fRunActions.insert(fRunActions.begin(), fBookedActions.begin(), fBookedActions.end());
fBookedActions.clear();
// reset children counts
fNChildren = 0;
fNStopsReceived = 0;
for (auto &ptr : fBookedFilters)
ptr->ResetChildrenCount();
for (auto &ptr : fBookedRanges)
ptr->ResetChildrenCount();
fCallbacks.clear();
fCallbacksOnce.clear();
}
/// Perform clean-up operations. To be called at the end of each task execution.
void RLoopManager::CleanUpTask(unsigned int slot)
{
for (auto &ptr : fBookedActions)
ptr->FinalizeSlot(slot);
for (auto &ptr : fBookedFilters)
ptr->ClearTask(slot);
}
/// Declare to the interpreter type aliases and other entities required by RDF jitted nodes.
/// This method clears the `fToJitDeclare` member variable.
void RLoopManager::JitDeclarations()
{
if (fToJitDeclare.empty())
return;
RDFInternal::InterpreterDeclare(fToJitDeclare);
fToJitDeclare.clear();
}
/// Add RDF nodes that require just-in-time compilation to the computation graph.
/// This method also invokes JitDeclarations() if needed, and clears the `fToJitExec` member variable.
void RLoopManager::Jit()
{
if (fToJitExec.empty())
return;
JitDeclarations();
RDFInternal::InterpreterCalc(fToJitExec, "RLoopManager::Run");
fToJitExec.clear();
}
/// Trigger counting of number of children nodes for each node of the functional graph.
/// This is done once before starting the event loop. Each action sends an `increase children count` signal
/// upstream, which is propagated until RLoopManager. Each time a node receives the signal, in increments its
/// children counter. Each node only propagates the signal once, even if it receives it multiple times.
/// Named filters also send an `increase children count` signal, just like actions, as they always execute during
/// the event loop so the graph branch they belong to must count as active even if it does not end in an action.
void RLoopManager::EvalChildrenCounts()
{
for (auto &actionPtr : fBookedActions)
actionPtr->TriggerChildrenCount();
for (auto &namedFilterPtr : fBookedNamedFilters)
namedFilterPtr->TriggerChildrenCount();
}
unsigned int RLoopManager::GetNextID()
{
static unsigned int id = 0;
++id;
return id;
}
/// Start the event loop with a different mechanism depending on IMT/no IMT, data source/no data source.
/// Also perform a few setup and clean-up operations (jit actions if necessary, clear booked actions after the loop...).
void RLoopManager::Run()
{
Jit();
InitNodes();
switch (fLoopType) {
case ELoopType::kNoFilesMT: RunEmptySourceMT(); break;
case ELoopType::kROOTFilesMT: RunTreeProcessorMT(); break;
case ELoopType::kDataSourceMT: RunDataSourceMT(); break;
case ELoopType::kNoFiles: RunEmptySource(); break;
case ELoopType::kROOTFiles: RunTreeReader(); break;
case ELoopType::kDataSource: RunDataSource(); break;
}
CleanUpNodes();
fNRuns++;
}
/// Return the list of default columns -- empty if none was provided when constructing the RDataFrame
const ColumnNames_t &RLoopManager::GetDefaultColumnNames() const
{
return fDefaultColumns;
}
TTree *RLoopManager::GetTree() const
{
return fTree.get();
}
void RLoopManager::Book(RDFInternal::RActionBase *actionPtr)
{
fBookedActions.emplace_back(actionPtr);
}
void RLoopManager::Deregister(RDFInternal::RActionBase *actionPtr)
{
RDFInternal::Erase(actionPtr, fRunActions);
RDFInternal::Erase(actionPtr, fBookedActions);
}
void RLoopManager::Book(RFilterBase *filterPtr)
{
fBookedFilters.emplace_back(filterPtr);
if (filterPtr->HasName()) {
fBookedNamedFilters.emplace_back(filterPtr);
fMustRunNamedFilters = true;
}
}
void RLoopManager::Deregister(RFilterBase *filterPtr)
{
RDFInternal::Erase(filterPtr, fBookedFilters);
RDFInternal::Erase(filterPtr, fBookedNamedFilters);
}
void RLoopManager::Book(RRangeBase *rangePtr)
{
fBookedRanges.emplace_back(rangePtr);
}
void RLoopManager::Deregister(RRangeBase *rangePtr)
{
RDFInternal::Erase(rangePtr, fBookedRanges);
}
// dummy call, end of recursive chain of calls
bool RLoopManager::CheckFilters(unsigned int, Long64_t)
{
return true;
}
/// Call `FillReport` on all booked filters
void RLoopManager::Report(ROOT::RDF::RCutFlowReport &rep) const
{
for (const auto &fPtr : fBookedNamedFilters)
fPtr->FillReport(rep);
}
void RLoopManager::RegisterCallback(ULong64_t everyNEvents, std::function<void(unsigned int)> &&f)
{
if (everyNEvents == 0ull)
fCallbacksOnce.emplace_back(std::move(f), fNSlots);
else
fCallbacks.emplace_back(everyNEvents, std::move(f), fNSlots);
}
std::vector<std::string> RLoopManager::GetFiltersNames()
{
std::vector<std::string> filters;
for (auto &filter : fBookedFilters) {
auto name = (filter->HasName() ? filter->GetName() : "Unnamed Filter");
filters.push_back(name);
}
return filters;
}
std::vector<RDFInternal::RActionBase *> RLoopManager::GetAllActions()
{
std::vector<RDFInternal::RActionBase *> actions;
actions.insert(actions.begin(), fBookedActions.begin(), fBookedActions.end());
actions.insert(actions.begin(), fRunActions.begin(), fRunActions.end());
return actions;
}
std::shared_ptr<ROOT::Internal::RDF::GraphDrawing::GraphNode> RLoopManager::GetGraph()
{
std::string name;
if (fDataSource) {
name = fDataSource->GetLabel();
} else if (fTree) {
name = fTree->GetName();
} else {
name = std::to_string(fNEmptyEntries);
}
auto thisNode = std::make_shared<ROOT::Internal::RDF::GraphDrawing::GraphNode>(name);
thisNode->SetRoot();
thisNode->SetCounter(0);
return thisNode;
}
////////////////////////////////////////////////////////////////////////////
/// Return all valid TTree::Branch names (caching results for subsequent calls).
/// Never use fBranchNames directy, always request it through this method.
const ColumnNames_t &RLoopManager::GetBranchNames()
{
if (fValidBranchNames.empty() && fTree) {
fValidBranchNames = RDFInternal::GetBranchNames(*fTree, /*allowRepetitions=*/true);
}
return fValidBranchNames;
}
|
/*************************************************************************
*
* Copyright 2016 Realm Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**************************************************************************/
#include "testsettings.hpp"
#ifdef TEST_TABLE
#include <algorithm>
#include <limits>
#include <string>
#include <fstream>
#include <ostream>
#include <realm.hpp>
#include <realm/history.hpp>
#include <realm/lang_bind_helper.hpp>
#include <realm/util/buffer.hpp>
#include <realm/util/to_string.hpp>
#include "util/misc.hpp"
#include "test.hpp"
using namespace realm;
using namespace realm::util;
using namespace realm::test_util;
using unit_test::TestContext;
// Test independence and thread-safety
// -----------------------------------
//
// All tests must be thread safe and independent of each other. This
// is required because it allows for both shuffling of the execution
// order and for parallelized testing.
//
// In particular, avoid using std::rand() since it is not guaranteed
// to be thread safe. Instead use the API offered in
// `test/util/random.hpp`.
//
// All files created in tests must use the TEST_PATH macro (or one of
// its friends) to obtain a suitable file system path. See
// `test/util/test_path.hpp`.
//
//
// Debugging and the ONLY() macro
// ------------------------------
//
// A simple way of disabling all tests except one called `Foo`, is to
// replace TEST(Foo) with ONLY(Foo) and then recompile and rerun the
// test suite. Note that you can also use filtering by setting the
// environment varible `UNITTEST_FILTER`. See `README.md` for more on
// this.
//
// Another way to debug a particular test, is to copy that test into
// `experiments/testcase.cpp` and then run `sh build.sh
// check-testcase` (or one of its friends) from the command line.
namespace {
REALM_TABLE_2(TupleTableType, first, Int, second, String)
} // anonymous namespace
#ifdef JAVA_MANY_COLUMNS_CRASH
REALM_TABLE_3(SubtableType, year, Int, daysSinceLastVisit, Int, conceptId, String)
REALM_TABLE_7(MainTableType, patientId, String, gender, Int, ethnicity, Int, yearOfBirth, Int, yearOfDeath, Int,
zipCode, String, events, Subtable<SubtableType>)
TEST(Table_ManyColumnsCrash2)
{
// Trying to reproduce Java crash.
for (int a = 0; a < 10; a++) {
Group group;
MainTableType::Ref mainTable = group.add_table<MainTableType>("PatientTable");
TableRef dynPatientTable = group.add_table("PatientTable");
dynPatientTable->add_empty_row();
for (int counter = 0; counter < 20000; counter++) {
#if 0
// Add row to subtable through typed interface
SubtableType::Ref subtable = mainTable[0].events->get_table_ref();
REALM_ASSERT(subtable->is_attached());
subtable->add(0, 0, "");
REALM_ASSERT(subtable->is_attached());
#else
// Add row to subtable through dynamic interface. This mimics Java closest
TableRef subtable2 = dynPatientTable->get_subtable(6, 0);
REALM_ASSERT(subtable2->is_attached());
size_t subrow = subtable2->add_empty_row();
REALM_ASSERT(subtable2->is_attached());
#endif
if ((counter % 1000) == 0) {
// std::cerr << counter << "\n";
}
}
}
}
#endif // JAVA_MANY_COLUMNS_CRASH
TEST(Table_Null)
{
{
// Check that add_empty_row() adds NULL string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name", true); // nullable = true
table->add_empty_row();
CHECK(table->get_string(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
CHECK(!table->is_nullable(0));
table->add_empty_row();
CHECK(!table->get_string(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_string(0, 0, realm::null()), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds null integer as default
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "name", true /*nullable*/);
CHECK(table->is_nullable(0));
table->add_empty_row();
CHECK(table->is_null(0, 0));
}
{
// Check that add_empty_row() adds 0 integer as default.
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Int, "name");
CHECK(!table->is_nullable(0));
table->add_empty_row();
CHECK(!table->is_null(0, 0));
CHECK_EQUAL(0, table->get_int(0, 0));
// Check that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_null(0, 0), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds NULL binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name", true /*nullable*/);
CHECK(table->is_nullable(0));
table->add_empty_row();
CHECK(table->get_binary(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name");
CHECK(!table->is_nullable(0));
table->add_empty_row();
CHECK(!table->get_binary(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_THROW_ANY(table->set_binary(0, 0, BinaryData()));
}
{
// Check that link columns are nullable.
Group group;
TableRef target = group.add_table("target");
TableRef table = group.add_table("table");
target->add_column(type_Int, "int");
table->add_column_link(type_Link, "link", *target);
CHECK(table->is_nullable(0));
CHECK(!target->is_nullable(0));
}
{
// Check that linklist columns are not nullable.
Group group;
TableRef target = group.add_table("target");
TableRef table = group.add_table("table");
target->add_column(type_Int, "int");
table->add_column_link(type_LinkList, "link", *target);
CHECK(!table->is_nullable(0));
CHECK(!target->is_nullable(0));
}
}
TEST(Table_DeleteCrash)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
table->add_column(type_Int, "age");
table->add_empty_row(3);
table->set_string(0, 0, "Alice");
table->set_int(1, 0, 27);
table->set_string(0, 1, "Bob");
table->set_int(1, 1, 50);
table->set_string(0, 2, "Peter");
table->set_int(1, 2, 44);
table->remove(0);
table->remove(1);
}
TEST(Table_OptimizeCrash)
{
// This will crash at the .add() method
TupleTableType ttt;
ttt.optimize();
ttt.column().second.add_search_index();
ttt.clear();
ttt.add(1, "AA");
}
TEST(Table_1)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Int, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_int(1, ndx, 10);
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(10, table.get_int(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_int(0, i, 2 * i);
table.set_int(1, i, 20 * i);
}
for (size_t i = ndx; i < 7; ++i) {
const int64_t v1 = 2 * i;
const int64_t v2 = 20 * i;
CHECK_EQUAL(v1, table.get_int(0, i));
CHECK_EQUAL(v2, table.get_int(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_ColumnNameTooLong)
{
Group group;
TableRef table = group.add_table("foo");
const size_t buf_size = 64;
std::unique_ptr<char[]> buf(new char[buf_size]);
CHECK_LOGIC_ERROR(table->add_column(type_Int, StringData(buf.get(), buf_size)), LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column(0, type_Int, StringData(buf.get(), buf_size)),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->add_column_link(type_Link, StringData(buf.get(), buf_size), *table),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column_link(0, type_Link, StringData(buf.get(), buf_size), *table),
LogicError::column_name_too_long);
table->add_column(type_Int, StringData(buf.get(), buf_size - 1));
table->insert_column(0, type_Int, StringData(buf.get(), buf_size - 1));
table->add_column_link(type_Link, StringData(buf.get(), buf_size - 1), *table);
table->insert_column_link(0, type_Link, StringData(buf.get(), buf_size - 1), *table);
}
TEST(Table_StringOrBinaryTooBig)
{
Table table;
table.add_column(type_String, "s");
table.add_column(type_Binary, "b");
table.add_column(type_Mixed, "m1");
table.add_column(type_Mixed, "m2");
table.add_empty_row();
table.set_string(0, 0, "01234567");
size_t large_bin_size = 0xFFFFF1;
size_t large_str_size = 0xFFFFF0; // null-terminate reduces max size by 1
std::unique_ptr<char[]> large_buf(new char[large_bin_size]);
CHECK_LOGIC_ERROR(table.set_string(0, 0, StringData(large_buf.get(), large_str_size)),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size)),
LogicError::binary_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size))),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size))),
LogicError::binary_too_big);
table.set_string(0, 0, StringData(large_buf.get(), large_str_size - 1));
table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size - 1));
table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size - 1)));
table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size - 1)));
}
TEST(Table_SetBinaryLogicErrors)
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Binary, "a");
table->add_column(type_Int, "b");
table->add_empty_row();
BinaryData bd;
CHECK_LOGIC_ERROR(table->set_binary(2, 0, bd), LogicError::column_index_out_of_range);
CHECK_LOGIC_ERROR(table->set_binary(0, 1, bd), LogicError::row_index_out_of_range);
CHECK_LOGIC_ERROR(table->set_null(0, 0), LogicError::column_not_nullable);
// FIXME: Must also check that Logic::type_mismatch is thrown on column type mismatch, but Table::set_binary()
// does not properly check it yet.
group.remove_table("table");
CHECK_LOGIC_ERROR(table->set_binary(0, 0, bd), LogicError::detached_accessor);
// Logic error LogicError::binary_too_big checked in Table_StringOrBinaryTooBig
}
TEST(Table_Floats)
{
Table table;
table.add_column(type_Float, "first");
table.add_column(type_Double, "second");
CHECK_EQUAL(type_Float, table.get_column_type(0));
CHECK_EQUAL(type_Double, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_float(0, ndx, float(1.12));
table.set_double(1, ndx, double(102.13));
CHECK_EQUAL(float(1.12), table.get_float(0, ndx));
CHECK_EQUAL(double(102.13), table.get_double(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_float(0, i, float(1.12) + 100 * i);
table.set_double(1, i, double(102.13) * 200 * i);
}
for (size_t i = ndx; i < 7; ++i) {
const float v1 = float(1.12) + 100 * i;
const double v2 = double(102.13) * 200 * i;
CHECK_EQUAL(v1, table.get_float(0, i));
CHECK_EQUAL(v2, table.get_double(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
REALM_TABLE_4(TestTable, first, Int, second, Int, third, Bool, fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_2)
{
TestTable table;
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL(0, r.first);
CHECK_EQUAL(10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL(Wed, r.fourth);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_3)
{
TestTable table;
for (size_t i = 0; i < 100; ++i) {
table.add(0, 10, true, Wed);
}
// Test column searching
CHECK_EQUAL(size_t(0), table.column().first.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().first.find_first(1));
CHECK_EQUAL(size_t(0), table.column().second.find_first(10));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(100));
CHECK_EQUAL(size_t(0), table.column().third.find_first(true));
CHECK_EQUAL(size_t(-1), table.column().third.find_first(false));
CHECK_EQUAL(size_t(0), table.column().fourth.find_first(Wed));
CHECK_EQUAL(size_t(-1), table.column().fourth.find_first(Mon));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableEnum, first, Enum<Days>, second, String)
} // anonymous namespace
TEST(Table_4)
{
TestTableEnum table;
table.add(Mon, "Hello");
table.add(Mon, "HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello");
const TestTableEnum::Cursor r = table.back(); // last item
CHECK_EQUAL(Mon, r.first);
CHECK_EQUAL("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello", r.second);
// Test string column searching
CHECK_EQUAL(size_t(1), table.column().second.find_first(
"HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello"));
CHECK_EQUAL(size_t(-1), table.column().second.find_first("Foo"));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableFloats, first, Float, second, Double)
} // anonymous namespace
TEST(Table_Float2)
{
TestTableFloats table;
table.add(1.1f, 2.2);
table.add(1.1f, 2.2);
const TestTableFloats::Cursor r = table.back(); // last item
CHECK_EQUAL(1.1f, r.first);
CHECK_EQUAL(2.2, r.second);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Delete)
{
TestTable table;
for (size_t i = 0; i < 10; ++i) {
table.add(0, i, true, Wed);
}
table.remove(0);
table.remove(4);
table.remove(7);
CHECK_EQUAL(1, table[0].second);
CHECK_EQUAL(2, table[1].second);
CHECK_EQUAL(3, table[2].second);
CHECK_EQUAL(4, table[3].second);
CHECK_EQUAL(6, table[4].second);
CHECK_EQUAL(7, table[5].second);
CHECK_EQUAL(8, table[6].second);
#ifdef REALM_DEBUG
table.verify();
#endif
// Delete all items one at a time
for (size_t i = 0; i < 7; ++i) {
table.remove(0);
}
CHECK(table.is_empty());
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_GetName)
{
// Freestanding tables have no names
{
Table table;
CHECK_EQUAL("", table.get_name());
}
// ... regardless of how they are created
{
TableRef table = Table::create();
CHECK_EQUAL("", table->get_name());
}
// Direct members of groups do have names
{
Group group;
TableRef table = group.add_table("table");
CHECK_EQUAL("table", table->get_name());
}
{
Group group;
TableRef foo = group.add_table("foo");
TableRef bar = group.add_table("bar");
CHECK_EQUAL("foo", foo->get_name());
CHECK_EQUAL("bar", bar->get_name());
}
// Subtables should never have names
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "sub", &subdesc);
table.add_empty_row();
TableRef subtab = table.get_subtable(0, 0);
CHECK_EQUAL("", table.get_name());
CHECK_EQUAL("", subtab->get_name());
}
// ... not even when the parent is a member of a group
{
Group group;
TableRef table = group.add_table("table");
DescriptorRef subdesc;
table->add_column(type_Table, "sub", &subdesc);
table->add_empty_row();
TableRef subtab = table->get_subtable(0, 0);
CHECK_EQUAL("table", table->get_name());
CHECK_EQUAL("", subtab->get_name());
}
}
namespace {
void setup_multi_table(Table& table, size_t rows, size_t sub_rows, bool fixed_subtab_sizes = false)
{
// Create table with all column types
{
DescriptorRef sub1;
table.add_column(type_Int, "int"); // 0
table.add_column(type_Bool, "bool"); // 1
table.add_column(type_OldDateTime, "date"); // 2
table.add_column(type_Float, "float"); // 3
table.add_column(type_Double, "double"); // 4
table.add_column(type_String, "string"); // 5
table.add_column(type_String, "string_long"); // 6
table.add_column(type_String, "string_big_blobs"); // 7
table.add_column(type_String, "string_enum"); // 8 - becomes StringEnumColumn
table.add_column(type_Binary, "binary"); // 9
table.add_column(type_Table, "tables", &sub1); // 10
table.add_column(type_Mixed, "mixed"); // 11
table.add_column(type_Int, "int_null", true); // 12, nullable = true
sub1->add_column(type_Int, "sub_first");
sub1->add_column(type_String, "sub_second");
}
table.add_empty_row(rows);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
table.set_int(0, i, int64_t(i * sign));
if (i % 4 == 0) {
table.set_null(12, i);
}
else {
table.set_int(12, i, int64_t(i * sign));
}
}
for (size_t i = 0; i < rows; ++i)
table.set_bool(1, i, (i % 2 ? true : false));
for (size_t i = 0; i < rows; ++i)
table.set_olddatetime(2, i, 12345);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
table.set_float(3, i, 123.456f * sign);
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
table.set_double(4, i, 9876.54321 * sign);
}
std::vector<std::string> strings;
for (size_t i = 0; i < rows; ++i) {
std::stringstream out;
out << "string" << i;
strings.push_back(out.str());
}
for (size_t i = 0; i < rows; ++i)
table.set_string(5, i, strings[i]);
for (size_t i = 0; i < rows; ++i) {
std::string str_i(strings[i] + " very long string.........");
table.set_string(6, i, str_i);
}
for (size_t i = 0; i < rows; ++i) {
switch (i % 2) {
case 0: {
std::string s = strings[i];
s += " very long string.........";
for (int j = 0; j != 4; ++j)
s += " big blobs big blobs big blobs"; // +30
table.set_string(7, i, s);
break;
}
case 1:
table.set_string(7, i, "");
break;
}
}
for (size_t i = 0; i < rows; ++i) {
switch (i % 3) {
case 0:
table.set_string(8, i, "enum1");
break;
case 1:
table.set_string(8, i, "enum2");
break;
case 2:
table.set_string(8, i, "enum3");
break;
}
}
for (size_t i = 0; i < rows; ++i)
table.set_binary(9, i, BinaryData("binary", 7));
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
size_t n = sub_rows;
if (!fixed_subtab_sizes)
n += i;
for (size_t j = 0; j != n; ++j) {
TableRef subtable = table.get_subtable(10, i);
int64_t val = -123 + i * j * 1234 * sign;
subtable->insert_empty_row(j);
subtable->set_int(0, j, val);
subtable->set_string(1, j, "sub");
}
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
switch (i % 8) {
case 0:
table.set_mixed(11, i, false);
break;
case 1:
table.set_mixed(11, i, int64_t(i * i * sign));
break;
case 2:
table.set_mixed(11, i, "string");
break;
case 3:
table.set_mixed(11, i, OldDateTime(123456789));
break;
case 4:
table.set_mixed(11, i, BinaryData("binary", 7));
break;
case 5: {
// Add subtable to mixed column
// We can first set schema and contents when the entire
// row has been inserted
table.set_mixed(11, i, Mixed::subtable_tag());
TableRef subtable = table.get_subtable(11, i);
subtable->add_column(type_Int, "first");
subtable->add_column(type_String, "second");
for (size_t j = 0; j != 2; ++j) {
subtable->insert_empty_row(j);
subtable->set_int(0, j, i * i * j * sign);
subtable->set_string(1, j, "mixed sub");
}
break;
}
case 6:
table.set_mixed(11, i, float(123.1 * i * sign));
break;
case 7:
table.set_mixed(11, i, double(987.65 * i * sign));
break;
}
}
// We also want a StringEnumColumn
table.optimize();
}
} // anonymous namespace
TEST(Table_LowLevelCopy)
{
Table table;
setup_multi_table(table, 15, 2);
#ifdef REALM_DEBUG
table.verify();
#endif
Table table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TableRef table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_HighLevelCopy)
{
TestTable table;
table.add(10, 120, false, Mon);
table.add(12, 100, true, Tue);
#ifdef REALM_DEBUG
table.verify();
#endif
TestTable table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TestTable::Ref table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_DeleteAllTypes)
{
Table table;
setup_multi_table(table, 15, 2);
// Test Deletes
table.remove(14);
table.remove(0);
table.remove(5);
CHECK_EQUAL(12, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
// Test Clear
table.clear();
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
// Triggers a bug that would make Realm crash if you run optimize() followed by add_search_index()
TEST(Table_Optimize_SetIndex_Crash)
{
Table table;
table.add_column(type_String, "first");
table.add_empty_row(3);
table.set_string(0, 0, "string0");
table.set_string(0, 1, "string1");
table.set_string(0, 2, "string1");
table.optimize();
CHECK_NOT_EQUAL(0, table.get_descriptor()->get_num_unique_values(0));
table.set_string(0, 2, "string2");
table.add_search_index(0);
table.move_last_over(1);
table.move_last_over(1);
}
TEST(Table_MoveAllTypes)
{
Random random(random_int<unsigned long>()); // Seed from slow global generator
Table table;
setup_multi_table(table, 15, 2);
table.add_search_index(6);
while (!table.is_empty()) {
size_t size = table.size();
size_t target_row_ndx = random.draw_int_mod(size);
table.move_last_over(target_row_ndx);
table.verify();
}
}
TEST(Table_DegenerateSubtableSearchAndAggregate)
{
Table parent;
// Add all column types
{
DescriptorRef sub_1, sub_2;
parent.add_column(type_Table, "child", &sub_1);
sub_1->add_column(type_Int, "int"); // 0
sub_1->add_column(type_Bool, "bool"); // 1
sub_1->add_column(type_Float, "float"); // 2
sub_1->add_column(type_Double, "double"); // 3
sub_1->add_column(type_OldDateTime, "date"); // 4
sub_1->add_column(type_String, "string"); // 5
sub_1->add_column(type_Binary, "binary"); // 6
sub_1->add_column(type_Table, "table", &sub_2); // 7
sub_1->add_column(type_Mixed, "mixed"); // 8
sub_1->add_column(type_Int, "int_null", nullptr, true); // 9, nullable = true
sub_2->add_column(type_Int, "i");
}
parent.add_empty_row(); // Create a degenerate subtable
ConstTableRef degen_child = parent.get_subtable(0, 0); // NOTE: Constness is essential here!!!
CHECK_EQUAL(0, degen_child->size());
CHECK_EQUAL(10, degen_child->get_column_count());
// Searching:
// CHECK_EQUAL(0, degen_child->distinct(0).size()); // needs index but you cannot set index on ConstTableRef
CHECK_EQUAL(0, degen_child->get_sorted_view(0).size());
CHECK_EQUAL(not_found, degen_child->find_first_int(0, 0));
CHECK_EQUAL(not_found, degen_child->find_first_bool(1, false));
CHECK_EQUAL(not_found, degen_child->find_first_float(2, 0));
CHECK_EQUAL(not_found, degen_child->find_first_double(3, 0));
CHECK_EQUAL(not_found, degen_child->find_first_olddatetime(4, OldDateTime()));
CHECK_EQUAL(not_found, degen_child->find_first_string(5, StringData("")));
// CHECK_EQUAL(not_found, degen_child->find_first_binary(6, BinaryData())); // Exists but not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->find_all_int(0, 0).size());
CHECK_EQUAL(0, degen_child->find_all_bool(1, false).size());
CHECK_EQUAL(0, degen_child->find_all_float(2, 0).size());
CHECK_EQUAL(0, degen_child->find_all_double(3, 0).size());
CHECK_EQUAL(0, degen_child->find_all_olddatetime(4, OldDateTime()).size());
CHECK_EQUAL(0, degen_child->find_all_string(5, StringData("")).size());
// CHECK_EQUAL(0, degen_child->find_all_binary(6, BinaryData()).size()); // Exists but not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_subtable(7, subtab).size()); // Not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_mixed(8, Mixed()).size()); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->lower_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->lower_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->lower_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->lower_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->lower_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->upper_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->upper_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->upper_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->upper_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->upper_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_mixed(8, Mixed())); // Not yet implemented
// Aggregates:
CHECK_EQUAL(0, degen_child->count_int(0, 0));
// CHECK_EQUAL(0, degen_child->count_bool(1, false)); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_float(2, 0));
CHECK_EQUAL(0, degen_child->count_double(3, 0));
// CHECK_EQUAL(0, degen_child->count_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->count_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->minimum_int(0));
CHECK_EQUAL(0, degen_child->minimum_float(2));
CHECK_EQUAL(0, degen_child->minimum_double(3));
CHECK_EQUAL(0, degen_child->minimum_olddatetime(4));
CHECK_EQUAL(0, degen_child->maximum_int(0));
CHECK_EQUAL(0, degen_child->maximum_float(2));
CHECK_EQUAL(0, degen_child->maximum_double(3));
CHECK_EQUAL(0, degen_child->maximum_olddatetime(4));
CHECK_EQUAL(0, degen_child->sum_int(0));
CHECK_EQUAL(0, degen_child->sum_float(2));
CHECK_EQUAL(0, degen_child->sum_double(3));
CHECK_EQUAL(0, degen_child->average_int(0));
CHECK_EQUAL(0, degen_child->average_float(2));
CHECK_EQUAL(0, degen_child->average_double(3));
// Queries:
CHECK_EQUAL(not_found, degen_child->where().equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(1, false).find());
CHECK_EQUAL(not_found, degen_child->where().equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().equal_olddatetime(4, OldDateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().equal(8, Mixed()).find()); // Not yet implemented
CHECK_EQUAL(not_found, degen_child->where().not_equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal_olddatetime(4, OldDateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().not_equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().not_equal(8, Mixed()).find()); // Not yet implemented
TableView v = degen_child->where().equal(0, int64_t()).find_all();
CHECK_EQUAL(0, v.size());
v = degen_child->where().equal(5, "hello").find_all();
CHECK_EQUAL(0, v.size());
size_t r = degen_child->where().equal(5, "hello").count();
CHECK_EQUAL(0, r);
r = degen_child->where().equal(5, "hello").remove();
CHECK_EQUAL(0, r);
size_t res;
degen_child->where().equal(5, "hello").average_int(0, &res);
CHECK_EQUAL(0, res);
}
TEST(Table_Range)
{
Table table;
table.add_column(type_Int, "int");
table.add_empty_row(100);
for (size_t i = 0; i < 100; ++i)
table.set_int(0, i, i);
TableView tv = table.get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i < tv.size(); ++i)
CHECK_EQUAL(int64_t(i + 10), tv.get_int(0, i));
}
TEST(Table_RangeConst)
{
Group group;
{
TableRef table = group.add_table("test");
table->add_column(type_Int, "int");
table->add_empty_row(100);
for (int i = 0; i < 100; ++i)
table->set_int(0, i, i);
}
ConstTableRef ctable = group.get_table("test");
ConstTableView tv = ctable->get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i < tv.size(); ++i)
CHECK_EQUAL(int64_t(i + 10), tv.get_int(0, i));
}
// enable to generate testfiles for to_string below
#define GENERATE 0
TEST(Table_ToString)
{
Table table;
setup_multi_table(table, 15, 6);
std::stringstream ss;
table.to_string(ss);
const std::string result = ss.str();
std::string file_name = get_test_resource_path();
file_name += "expect_string.txt";
#if GENERATE // enable to generate testfile - check it manually
std::ofstream test_file(file_name.c_str(), std::ios::out);
test_file << result;
std::cerr << "to_string() test:\n" << result << std::endl;
#else
std::ifstream test_file(file_name.c_str(), std::ios::in);
CHECK(!test_file.fail());
std::string expected;
expected.assign(std::istreambuf_iterator<char>(test_file), std::istreambuf_iterator<char>());
bool test_ok = test_util::equal_without_cr(result, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
TEST_PATH(path);
File out(path, File::mode_Write);
out.write(result);
std::cerr << "\n error result in '" << std::string(path) << "'\n";
}
#endif
}
/* DISABLED BECAUSE IT FAILS - A PULL REQUEST WILL BE MADE WHERE IT IS REENABLED!
TEST(Table_RowToString)
{
// Create table with all column types
Table table;
setup_multi_table(table, 2, 2);
std::stringstream ss;
table.row_to_string(1, ss);
const std::string row_str = ss.str();
#if 0
std::ofstream test_file("row_to_string.txt", ios::out);
test_file << row_str;
#endif
std::string expected = " int bool date float double string
string_long string_enum binary mixed tables\n"
"1: -1 true 1970-01-01 03:25:45 -1.234560e+002 -9.876543e+003 string1 string1 very long
st... enum2 7 bytes -1 [3]\n";
bool test_ok = test_util::equal_without_cr(row_str, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
std::cerr << "row_to_string() failed\n"
<< "Expected: " << expected << "\n"
<< "Got : " << row_str << std::endl;
}
}
TEST(Table_FindInt)
{
TestTable table;
for (int i = 1000; i >= 0; --i) {
table.add(0, i, true, Wed);
}
CHECK_EQUAL(size_t(0), table.column().second.find_first(1000));
CHECK_EQUAL(size_t(1000), table.column().second.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(1001));
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
/*
TEST(Table_6)
{
TestTableEnum table;
RLM_QUERY(TestQuery, TestTableEnum) {
// first.between(Mon, Thu);
second == "Hello" || (second == "Hey" && first == Mon);
}};
RLM_QUERY_OPT(TestQuery2, TestTableEnum) (Days a, Days b, const char* str) {
static_cast<void>(b);
static_cast<void>(a);
//first.between(a, b);
second == str || second.MatchRegEx(".*");
}};
//TestTableEnum result = table.find_all(TestQuery2(Mon, Tue, "Hello")).sort().Limit(10);
//size_t result2 = table.Range(10, 200).find_first(TestQuery());
//CHECK_EQUAL((size_t)-1, result2);
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
TEST(Table_FindAllInt)
{
TestTable table;
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
// Search for a value that does not exits
const TestTable::View v0 = table.column().second.find_all(5);
CHECK_EQUAL(0, v0.size());
// Search for a value with several matches
const TestTable::View v = table.column().second.find_all(20);
CHECK_EQUAL(5, v.size());
CHECK_EQUAL(1, v.get_source_ndx(0));
CHECK_EQUAL(3, v.get_source_ndx(1));
CHECK_EQUAL(5, v.get_source_ndx(2));
CHECK_EQUAL(7, v.get_source_ndx(3));
CHECK_EQUAL(9, v.get_source_ndx(4));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_SortedInt)
{
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, true, Wed); // 1: 7
table.add(0, 0, true, Wed); // 2: 0
table.add(0, 40, true, Wed); // 3: 8
table.add(0, 15, true, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Search for a value that does not exits
TestTable::View v = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v.size());
CHECK_EQUAL(2, v.get_source_ndx(0));
CHECK_EQUAL(9, v.get_source_ndx(1));
CHECK_EQUAL(7, v.get_source_ndx(2));
CHECK_EQUAL(6, v.get_source_ndx(3));
CHECK_EQUAL(0, v.get_source_ndx(4));
CHECK_EQUAL(5, v.get_source_ndx(5));
CHECK_EQUAL(4, v.get_source_ndx(6));
CHECK_EQUAL(1, v.get_source_ndx(7));
CHECK_EQUAL(3, v.get_source_ndx(8));
CHECK_EQUAL(8, v.get_source_ndx(9));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Sorted_Query_where)
{
// Using where(tv) instead of tableview(tv)
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, false, Wed); // 1: 7
table.add(0, 0, false, Wed); // 2: 0
table.add(0, 40, false, Wed); // 3: 8
table.add(0, 15, false, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Count booleans
size_t count_original = table.where().third.equal(false).count();
CHECK_EQUAL(4, count_original);
// Get a view containing the complete table
TestTable::View v = table.column().first.find_all(0);
CHECK_EQUAL(table.size(), v.size());
// Count booleans
size_t count_view = table.where(&v).third.equal(false).count();
CHECK_EQUAL(4, count_view);
TestTable::View v_sorted = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v_sorted.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Multi_Sort)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
table.add_empty_row(5);
// 1, 10
table.set_int(0, 0, 1);
table.set_int(1, 0, 10);
// 2, 10
table.set_int(0, 1, 2);
table.set_int(1, 1, 10);
// 0, 10
table.set_int(0, 2, 0);
table.set_int(1, 2, 10);
// 2, 14
table.set_int(0, 3, 2);
table.set_int(1, 3, 14);
// 1, 14
table.set_int(0, 4, 1);
table.set_int(1, 4, 14);
std::vector<std::vector<size_t>> col_ndx1 = {{0}, {1}};
std::vector<bool> asc = {true, true};
// (0, 10); (1, 10); (1, 14); (2, 10); (2; 14)
TableView v_sorted1 = table.get_sorted_view(SortDescriptor{table, col_ndx1, asc});
CHECK_EQUAL(table.size(), v_sorted1.size());
CHECK_EQUAL(2, v_sorted1.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted1.get_source_ndx(1));
CHECK_EQUAL(4, v_sorted1.get_source_ndx(2));
CHECK_EQUAL(1, v_sorted1.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted1.get_source_ndx(4));
std::vector<std::vector<size_t>> col_ndx2 = {{1}, {0}};
// (0, 10); (1, 10); (2, 10); (1, 14); (2, 14)
TableView v_sorted2 = table.get_sorted_view(SortDescriptor{table, col_ndx2, asc});
CHECK_EQUAL(table.size(), v_sorted2.size());
CHECK_EQUAL(2, v_sorted2.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted2.get_source_ndx(1));
CHECK_EQUAL(1, v_sorted2.get_source_ndx(2));
CHECK_EQUAL(4, v_sorted2.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted2.get_source_ndx(4));
}
TEST(Table_IndexString)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); // duplicate
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
const size_t r1 = table.column().second.find_first("jimmi");
CHECK_EQUAL(not_found, r1);
const size_t r2 = table.column().second.find_first("jeff");
const size_t r3 = table.column().second.find_first("jim");
const size_t r4 = table.column().second.find_first("jimbo");
const size_t r5 = table.column().second.find_first("johnny");
CHECK_EQUAL(0, r2);
CHECK_EQUAL(1, r3);
CHECK_EQUAL(5, r4);
CHECK_EQUAL(6, r5);
const size_t c1 = table.column().second.count("jennifer");
CHECK_EQUAL(2, c1);
}
TEST(Table_IndexStringTwice)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); // duplicate
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
}
// Tests Table part of index on Int, OldDateTime and Bool columns. For a more exhaustive
// test of the integer index (bypassing Table), see test_index_string.cpp)
TEST(Table_IndexInteger)
{
Table table;
size_t r;
table.add_column(type_Int, "ints");
table.add_column(type_OldDateTime, "date");
table.add_column(type_Bool, "date");
table.add_empty_row(13);
table.set_int(0, 0, 3); // 0
table.set_int(0, 1, 1); // 1
table.set_int(0, 2, 2); // 2
table.set_int(0, 3, 2); // 3
table.set_int(0, 4, 2); // 4
table.set_int(0, 5, 3); // 5
table.set_int(0, 6, 3); // 6
table.set_int(0, 7, 2); // 7
table.set_int(0, 8, 4); // 8
table.set_int(0, 9, 2); // 9
table.set_int(0, 10, 6); // 10
table.set_int(0, 11, 2); // 11
table.set_int(0, 12, 3); // 12
table.add_search_index(0);
CHECK(table.has_search_index(0));
table.add_search_index(1);
CHECK(table.has_search_index(1));
table.add_search_index(2);
CHECK(table.has_search_index(2));
table.set_olddatetime(1, 10, OldDateTime(43));
r = table.find_first_olddatetime(1, OldDateTime(43));
CHECK_EQUAL(10, r);
table.set_bool(2, 11, true);
r = table.find_first_bool(2, true);
CHECK_EQUAL(11, r);
r = table.find_first_int(0, 11);
CHECK_EQUAL(not_found, r);
r = table.find_first_int(0, 3);
CHECK_EQUAL(0, r);
r = table.find_first_int(0, 4);
CHECK_EQUAL(8, r);
TableView tv = table.find_all_int(0, 2);
CHECK_EQUAL(6, tv.size());
CHECK_EQUAL(2, tv[0].get_index());
CHECK_EQUAL(3, tv[1].get_index());
CHECK_EQUAL(4, tv[2].get_index());
CHECK_EQUAL(7, tv[3].get_index());
CHECK_EQUAL(9, tv[4].get_index());
CHECK_EQUAL(11, tv[5].get_index());
}
TEST(Table_SetIntUnique)
{
Table table;
table.add_column(type_Int, "ints");
table.add_column(type_Int, "ints_null", true);
table.add_column(type_Int, "ints_null", true);
table.add_empty_row(10);
CHECK_LOGIC_ERROR(table.set_int_unique(0, 0, 123), LogicError::no_search_index);
CHECK_LOGIC_ERROR(table.set_int_unique(1, 0, 123), LogicError::no_search_index);
CHECK_LOGIC_ERROR(table.set_null_unique(2, 0), LogicError::no_search_index);
table.add_search_index(0);
table.add_search_index(1);
table.add_search_index(2);
table.set_int_unique(0, 0, 123);
CHECK_EQUAL(table.size(), 10);
table.set_int_unique(1, 0, 123);
CHECK_EQUAL(table.size(), 10);
table.set_int_unique(2, 0, 123);
CHECK_EQUAL(table.size(), 10);
// Check that conflicting SetIntUniques result in rows being deleted. First a collision in column 0:
table.set_int_unique(0, 1, 123); // This will delete row 1
CHECK_EQUAL(table.size(), 9);
table.set_int_unique(1, 1, 123); // This will delete row 1
CHECK_EQUAL(table.size(), 8);
table.set_int_unique(1, 2, 123); // This will delete row 1
CHECK_EQUAL(table.size(), 7);
// Collision in column 1:
table.set_int_unique(1, 0, 123); // no-op
CHECK_EQUAL(table.size(), 7);
table.set_int_unique(0, 0, 123); // no-op
CHECK_EQUAL(table.size(), 7);
table.set_int_unique(2, 0, 123); // no-op
CHECK_EQUAL(table.size(), 7);
// Collision in column 2:
table.set_int_unique(2, 1, 123); // This will delete a row
CHECK_EQUAL(table.size(), 6);
table.set_int_unique(0, 1, 123); // This will delete a row
CHECK_EQUAL(table.size(), 5);
table.set_int_unique(1, 1, 123); // This will delete a row
CHECK_EQUAL(table.size(), 4);
// Since table.add_empty_row(10); filled the column with all nulls, only two rows should now remain
table.set_null_unique(2, 1);
CHECK_EQUAL(table.size(), 2);
table.set_null_unique(2, 0);
CHECK_EQUAL(table.size(), 1);
}
TEST_TYPES(Table_SetStringUnique, std::true_type, std::false_type)
{
bool string_enum_column = TEST_TYPE::value;
Table table;
table.add_column(type_Int, "ints");
table.add_column(type_String, "strings");
table.add_column(type_String, "strings_nullable", true);
table.add_empty_row(10); // all duplicates!
CHECK_LOGIC_ERROR(table.set_string_unique(1, 0, "foo"), LogicError::no_search_index);
CHECK_LOGIC_ERROR(table.set_string_unique(2, 0, "foo"), LogicError::no_search_index);
table.add_search_index(1);
table.add_search_index(2);
if (string_enum_column) {
bool force = true;
table.optimize(force);
}
table.set_string_unique(1, 0, "bar");
// Check that conflicting SetStringUniques result in rows with duplicate values being deleted.
table.set_string_unique(1, 1, "bar");
CHECK_EQUAL(table.size(), 9); // Only duplicates of "bar" are removed.
table.set_string_unique(2, 0, realm::null());
CHECK_EQUAL(table.size(), 1);
}
TEST(Table_AddInt)
{
Table t;
t.add_column(type_Int, "i");
t.add_column(type_Int, "ni", /*nullable*/ true);
t.add_empty_row(1);
t.add_int(0, 0, 1);
CHECK_EQUAL(t.get_int(0, 0), 1);
// Check that signed integers wrap around. This invariant is necessary for
// full commutativity.
t.add_int(0, 0, Table::max_integer);
CHECK_EQUAL(t.get_int(0, 0), Table::min_integer);
t.add_int(0, 0, -1);
CHECK_EQUAL(t.get_int(0, 0), Table::max_integer);
// add_int() has no effect on a NULL
CHECK(t.is_null(1, 0));
CHECK_LOGIC_ERROR(t.add_int(1, 0, 123), LogicError::illegal_combination);
}
TEST(Table_SetUniqueAccessorUpdating)
{
Group g;
TableRef origin = g.add_table("origin");
TableRef target = g.add_table("target");
target->add_column(type_Int, "col");
origin->add_column(type_Int, "pk");
origin->add_column_link(type_LinkList, "list", *target);
origin->add_search_index(0);
origin->add_empty_row(2);
origin->set_int_unique(0, 0, 1);
origin->set_int_unique(0, 1, 2);
Row row_0 = (*origin)[0];
Row row_1 = (*origin)[1];
LinkViewRef lv_0 = origin->get_linklist(1, 0);
LinkViewRef lv_1 = origin->get_linklist(1, 1);
// check new row number > old row number
origin->add_empty_row(2);
// leaves row 0 as winner, move last over of 2
origin->set_int_unique(0, 2, 1);
CHECK_EQUAL(origin->size(), 3);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK_EQUAL(row_0.get_index(), 0);
CHECK_EQUAL(row_1.get_index(), 1);
CHECK(lv_0->is_attached());
CHECK(lv_1->is_attached());
CHECK(lv_0 == origin->get_linklist(1, 0));
CHECK(lv_1 == origin->get_linklist(1, 1));
// check new row number < old row number
origin->insert_empty_row(0, 2);
CHECK_EQUAL(origin->size(), 5);
// winner is row 3, row 0 is deleted via move_last_over(0)
origin->set_int_unique(0, 0, 2);
CHECK_EQUAL(origin->size(), 4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK_EQUAL(row_0.get_index(), 2); // unchanged
CHECK_EQUAL(row_1.get_index(), 3); // unchanged
CHECK(lv_0->is_attached());
CHECK(lv_1->is_attached());
CHECK(lv_0 == origin->get_linklist(1, 2));
CHECK(lv_1 == origin->get_linklist(1, 3));
}
TEST(Table_SetUniqueLoserAccessorUpdates)
{
Group g;
TableRef origin = g.add_table("origin");
TableRef target = g.add_table("target");
target->add_column(type_Int, "col");
target->add_empty_row(6);
size_t int_col = origin->add_column(type_Int, "pk");
size_t ll_col = origin->add_column_link(type_LinkList, "list", *target);
size_t str_col = origin->add_column(type_String, "description");
origin->add_search_index(0);
origin->add_search_index(2);
origin->add_empty_row(4);
origin->set_int_unique(int_col, 0, 1);
origin->set_int_unique(int_col, 1, 2);
origin->set_string(str_col, 0, "zero");
origin->set_string(str_col, 1, "one");
origin->set_string(str_col, 2, "two");
origin->set_string(str_col, 3, "three");
Row row_0 = (*origin)[0];
Row row_1 = (*origin)[1];
Row row_2 = (*origin)[2];
LinkViewRef lv_0 = origin->get_linklist(ll_col, 0);
LinkViewRef lv_1 = origin->get_linklist(ll_col, 1);
LinkViewRef lv_2 = origin->get_linklist(ll_col, 2);
lv_0->add(0); // one link
lv_1->add(1); // two links
lv_1->add(2);
lv_2->add(3); // three links
lv_2->add(4);
lv_2->add(5);
CHECK_EQUAL(origin->size(), 4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(row_0.get_string(str_col), "zero");
CHECK_EQUAL(row_1.get_string(str_col), "one");
CHECK_EQUAL(row_2.get_string(str_col), "two");
// leaves row 0 as winner, move last over of 2
origin->set_int_unique(int_col, 2, 1);
CHECK_EQUAL(origin->size(), 3);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(row_0.get_index(), 0);
CHECK_EQUAL(row_1.get_index(), 1);
CHECK_EQUAL(row_2.get_index(), 0);
CHECK_EQUAL(row_0.get_string(str_col), "zero");
CHECK_EQUAL(row_1.get_string(str_col), "one");
CHECK_EQUAL(row_2.get_string(str_col), "zero");
CHECK_EQUAL(row_0.get_linklist(ll_col)->size(), 1);
CHECK_EQUAL(row_1.get_linklist(ll_col)->size(), 2);
CHECK_EQUAL(row_2.get_linklist(ll_col)->size(), 1); // subsumed
CHECK_EQUAL(lv_0->size(), 1);
CHECK_EQUAL(lv_1->size(), 2);
CHECK_EQUAL(lv_2->size(), 0); // direct access, 0 links comes from move_last_over(2)
CHECK(lv_0->is_attached());
CHECK(lv_1->is_attached());
CHECK(lv_0 == origin->get_linklist(1, 0));
CHECK(lv_1 == origin->get_linklist(1, 1));
}
TEST(Table_Distinct)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
TestTableEnum::View view = table.column().second.get_distinct_view();
CHECK_EQUAL(4, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(5, view.get_source_ndx(3));
}
TEST(Table_DistinctEnums)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().first.add_search_index();
CHECK(table.column().first.has_search_index());
TestTableEnum::View view = table.column().first.get_distinct_view();
CHECK_EQUAL(7, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(3, view.get_source_ndx(3));
CHECK_EQUAL(4, view.get_source_ndx(4));
CHECK_EQUAL(5, view.get_source_ndx(5));
CHECK_EQUAL(6, view.get_source_ndx(6));
}
TEST(Table_DistinctIntegers)
{
Table table;
table.add_column(type_Int, "first");
table.add_empty_row(4);
table.set_int(0, 0, 1);
table.set_int(0, 1, 2);
table.set_int(0, 2, 3);
table.set_int(0, 3, 3);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
TEST(Table_DistinctBool)
{
Table table;
table.add_column(type_Bool, "first");
table.add_empty_row(4);
table.set_bool(0, 0, true);
table.set_bool(0, 1, false);
table.set_bool(0, 2, true);
table.set_bool(0, 3, false);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(2, view.size());
CHECK_EQUAL(0, view.get_source_ndx(1));
CHECK_EQUAL(1, view.get_source_ndx(0));
}
/*
// FIXME Commented out because indexes on floats and doubles are not supported (yet).
TEST(Table_DistinctFloat)
{
Table table;
table.add_column(type_Float, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_float(0, i, static_cast<float>(i) + 0.5f);
}
table.set_float(0, 10, 0.5f);
table.set_float(0, 11, 1.5f);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
TEST(Table_DistinctDouble)
{
Table table;
table.add_column(type_Double, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_double(0, i, static_cast<double>(i) + 0.5);
}
table.set_double(0, 10, 0.5);
table.set_double(0, 11, 1.5);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
*/
TEST(Table_DistinctDateTime)
{
Table table;
table.add_column(type_OldDateTime, "first");
table.add_empty_row(4);
table.set_olddatetime(0, 0, OldDateTime(0));
table.set_olddatetime(0, 1, OldDateTime(1));
table.set_olddatetime(0, 2, OldDateTime(3));
table.set_olddatetime(0, 3, OldDateTime(3));
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
}
TEST(Table_DistinctFromPersistedTable)
{
GROUP_TEST_PATH(path);
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "first");
table->add_empty_row(4);
table->set_int(0, 0, 1);
table->set_int(0, 1, 2);
table->set_int(0, 2, 3);
table->set_int(0, 3, 3);
table->add_search_index(0);
CHECK(table->has_search_index(0));
group.write(path);
}
{
Group group(path, 0, Group::mode_ReadOnly);
TableRef table = group.get_table("table");
TableView view = table->get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
}
TEST(Table_IndexInt)
{
TestTable table;
table.add(0, 1, true, Wed);
table.add(0, 15, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 11, true, Wed);
table.add(0, 45, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 0, true, Wed);
table.add(0, 30, true, Wed);
table.add(0, 9, true, Wed);
// Create index for column two
table.column().second.add_search_index();
// Search for a value that does not exits
const size_t r1 = table.column().second.find_first(2);
CHECK_EQUAL(npos, r1);
// Find existing values
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(10));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
// CHECK_EQUAL(6, table.column().second.find_first(10)); // only finds first match
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(9));
// Change some values
table[2].second = 13;
table[9].second = 100;
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
// Insert values
table.add(0, 29, true, Wed);
// TODO: More than add
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
CHECK_EQUAL(10, table.column().second.find_first(29));
// Delete some values
table.remove(0);
table.remove(5);
table.remove(8);
CHECK_EQUAL(0, table.column().second.find_first(15));
CHECK_EQUAL(1, table.column().second.find_first(13));
CHECK_EQUAL(2, table.column().second.find_first(20));
CHECK_EQUAL(3, table.column().second.find_first(11));
CHECK_EQUAL(4, table.column().second.find_first(45));
CHECK_EQUAL(5, table.column().second.find_first(0));
CHECK_EQUAL(6, table.column().second.find_first(30));
CHECK_EQUAL(7, table.column().second.find_first(100));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_4(TestTableAE, first, Int, second, String, third, Bool, fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_AutoEnumeration)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
for (size_t i = 0; i < 5; ++i) {
const size_t n = i * 5;
CHECK_EQUAL(1, table[0 + n].first);
CHECK_EQUAL(2, table[1 + n].first);
CHECK_EQUAL(5, table[2 + n].first);
CHECK_EQUAL(8, table[3 + n].first);
CHECK_EQUAL(9, table[4 + n].first);
CHECK_EQUAL("abd", table[0 + n].second);
CHECK_EQUAL("eftg", table[1 + n].second);
CHECK_EQUAL("hijkl", table[2 + n].second);
CHECK_EQUAL("mnopqr", table[3 + n].second);
CHECK_EQUAL("stuvxyz", table[4 + n].second);
CHECK_EQUAL(true, table[0 + n].third);
CHECK_EQUAL(true, table[1 + n].third);
CHECK_EQUAL(true, table[2 + n].third);
CHECK_EQUAL(true, table[3 + n].third);
CHECK_EQUAL(true, table[4 + n].third);
CHECK_EQUAL(Mon, table[0 + n].fourth);
CHECK_EQUAL(Tue, table[1 + n].fourth);
CHECK_EQUAL(Wed, table[2 + n].fourth);
CHECK_EQUAL(Thu, table[3 + n].fourth);
CHECK_EQUAL(Fri, table[4 + n].fourth);
}
// Verify counts
const size_t count1 = table.column().second.count("abd");
const size_t count2 = table.column().second.count("eftg");
const size_t count3 = table.column().second.count("hijkl");
const size_t count4 = table.column().second.count("mnopqr");
const size_t count5 = table.column().second.count("stuvxyz");
CHECK_EQUAL(5, count1);
CHECK_EQUAL(5, count2);
CHECK_EQUAL(5, count3);
CHECK_EQUAL(5, count4);
CHECK_EQUAL(5, count5);
}
TEST(Table_AutoEnumerationFindFindAll)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
size_t t = table.column().second.find_first("eftg");
CHECK_EQUAL(1, t);
TestTableAE::View tv = table.column().second.find_all("eftg");
CHECK_EQUAL(5, tv.size());
CHECK_EQUAL("eftg", tv[0].second);
CHECK_EQUAL("eftg", tv[1].second);
CHECK_EQUAL("eftg", tv[2].second);
CHECK_EQUAL("eftg", tv[3].second);
CHECK_EQUAL("eftg", tv[4].second);
}
namespace {
REALM_TABLE_4(TestTableEnum4, col1, String, col2, String, col3, String, col4, String)
} // anonymous namespace
TEST(Table_AutoEnumerationOptimize)
{
TestTableEnum4 t;
// Insert non-optimzable strings
std::string s;
for (size_t i = 0; i < 10; ++i) {
t.add(s.c_str(), s.c_str(), s.c_str(), s.c_str());
s += "x";
}
t.optimize();
// AutoEnumerate in reverse order
for (size_t i = 0; i < 10; ++i) {
t[i].col4 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col3 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col2 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col1 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
CHECK_EQUAL("test", t[i].col1);
CHECK_EQUAL("test", t[i].col2);
CHECK_EQUAL("test", t[i].col3);
CHECK_EQUAL("test", t[i].col4);
}
#ifdef REALM_DEBUG
t.verify();
#endif
}
namespace {
REALM_TABLE_1(TestSubtabEnum2, str, String)
REALM_TABLE_1(TestSubtabEnum1, subtab, Subtable<TestSubtabEnum2>)
} // anonymous namespace
TEST(Table_OptimizeSubtable)
{
TestSubtabEnum1 t;
t.add();
t.add();
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (int i = 0; i < 100; ++i) {
r->add(s.c_str());
s += 'x';
}
}
{
// Enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (int i = 0; i < 100; ++i) {
r->add("foo");
}
r->optimize();
}
// Verify
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL(s.c_str(), r[i].str);
s += 'x';
}
}
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL("foo", r[i].str);
}
}
}
TEST(Table_OptimizeCompare)
{
TestSubtabEnum2 t1, t2;
for (int i = 0; i < 100; ++i) {
t1.add("foo");
}
for (int i = 0; i < 100; ++i) {
t2.add("foo");
}
t1.optimize();
CHECK(t1 == t2);
t1[50].str = "bar";
CHECK(t1 != t2);
t1[50].str = "foo";
CHECK(t1 == t2);
t2[50].str = "bar";
CHECK(t1 != t2);
t2[50].str = "foo";
CHECK(t1 == t2);
}
TEST(Table_SlabAlloc)
{
SlabAlloc alloc;
alloc.attach_empty();
TestTable table(alloc);
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL(0, r.first);
CHECK_EQUAL(10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL(Wed, r.fourth);
// Add some more rows
table.add(1, 10, true, Wed);
table.add(2, 20, true, Wed);
table.add(3, 10, true, Wed);
table.add(4, 20, true, Wed);
table.add(5, 10, true, Wed);
// Delete some rows
table.remove(2);
table.remove(4);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Spec)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
{
DescriptorRef sub_1;
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third", &sub_1);
sub_1->add_column(type_Int, "sub_first");
sub_1->add_column(type_String, "sub_second");
}
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Write the group to disk
GROUP_TEST_PATH(path);
group.write(path);
// Read back tables
{
Group from_disk(path, 0, Group::mode_ReadOnly);
TableRef from_disk_table = from_disk.get_table("test");
TableRef subtable2 = from_disk_table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("test", subtable2->get_string(1, 0));
}
}
TEST(Table_SpecColumnPath)
{
Group group;
TableRef table = group.add_table("test");
// Create path to sub-table column (starting with root)
std::vector<size_t> column_path;
// Create specification with sub-table
table->add_subcolumn(column_path, type_Int, "first");
table->add_subcolumn(column_path, type_String, "second");
table->add_subcolumn(column_path, type_Table, "third");
column_path.push_back(2); // third column (which is a sub-table col)
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
}
TEST(Table_SpecRenameColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Rename first column
table->rename_column(0, "1st");
CHECK_EQUAL(0, table->get_column_index("1st"));
// Rename sub-column
table->rename_subcolumn(column_path, 0, "sub_1st"); // third
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(0, subtable->get_column_index("sub_1st"));
}
}
TEST(Table_SpecDeleteColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
table->add_column(type_String, "fourth"); // will be auto-enumerated
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(4, table->get_column_count());
// Add a few rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->set_string(3, 0, "X");
table->insert_empty_row(1);
table->set_int(0, 1, 4);
table->set_string(1, 1, "World");
table->set_string(3, 1, "X");
table->insert_empty_row(2);
table->set_int(0, 2, 4);
table->set_string(1, 2, "Goodbye");
table->set_string(3, 2, "X");
// We want the last column to be StringEnum column
table->optimize();
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Remove the first column
table->remove_column(0);
CHECK_EQUAL(3, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(2, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Create path to column in sub-table
column_path.clear();
column_path.push_back(1); // third
// Remove a column in sub-table
table->remove_subcolumn(column_path, 1); // sub_second
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(1, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
}
// Remove sub-table column (with all members)
table->remove_column(1);
CHECK_EQUAL(2, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(1, 0));
// Remove optimized string column
table->remove_column(1);
CHECK_EQUAL(1, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
// Remove last column
table->remove_column(0);
CHECK_EQUAL(0, table->get_column_count());
CHECK(table->is_empty());
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_SpecMoveColumns)
{
using df = _impl::DescriptorFriend;
Group group;
TableRef foo = group.add_table("foo");
foo->add_column(type_Int, "a");
foo->add_column(type_Float, "b");
foo->add_column(type_Table, "c");
DescriptorRef foo_descriptor = foo->get_descriptor();
DescriptorRef c_descriptor = foo_descriptor->get_subdescriptor(2);
c_descriptor->add_column(type_Int, "c_a");
c_descriptor->add_column(type_Float, "c_b");
foo->add_empty_row();
foo->add_empty_row();
TableRef subtable0 = foo->get_subtable(2, 0);
subtable0->add_empty_row();
subtable0->set_int(0, 0, 123);
df::move_column(*foo_descriptor, 0, 2);
CHECK_EQUAL(foo_descriptor->get_column_type(1), type_Table);
CHECK_EQUAL(foo_descriptor->get_column_name(1), "c");
CHECK(c_descriptor->is_attached());
CHECK(subtable0->is_attached());
CHECK_EQUAL(123, subtable0->get_int(0, 0));
TableRef subtable1 = foo->get_subtable(1, 1);
subtable1->add_empty_row();
subtable1->set_int(0, 0, 456);
df::move_column(*c_descriptor, 0, 1);
CHECK(subtable0->is_attached());
CHECK(subtable1->is_attached());
CHECK_EQUAL(subtable0->get_int(1, 0), 123);
CHECK_EQUAL(subtable1->get_int(1, 0), 456);
}
TEST(Table_SpecMoveLinkColumn)
{
using df = _impl::DescriptorFriend;
Group group;
TableRef target = group.add_table("target");
target->add_column(type_Int, "a");
TableRef origin = group.add_table("origin");
origin->add_column_link(type_Link, "a", *target);
origin->add_column(type_Int, "b");
origin->add_empty_row(2);
target->add_empty_row(2);
origin->set_link(0, 0, 1);
df::move_column(*origin->get_descriptor(), 0, 1);
CHECK_EQUAL(origin->get_link(1, 0), 1);
CHECK_EQUAL(target->get_backlink_count(0, *origin, 1), 0);
CHECK_EQUAL(target->get_backlink_count(1, *origin, 1), 1);
}
TEST(Table_SpecMoveColumnsWithIndexes)
{
using df = _impl::DescriptorFriend;
using tf = _impl::TableFriend;
Group group;
TableRef foo = group.add_table("foo");
DescriptorRef desc = foo->get_descriptor();
foo->add_column(type_Int, "a");
foo->add_search_index(0);
foo->add_column(type_Int, "b");
StringIndex* a_index = tf::get_column(*foo, 0).get_search_index();
CHECK_EQUAL(1, a_index->get_ndx_in_parent());
df::move_column(*desc, 0, 1);
CHECK_EQUAL(2, a_index->get_ndx_in_parent());
auto& spec = df::get_spec(*desc);
CHECK(foo->has_search_index(1));
CHECK((spec.get_column_attr(1) & col_attr_Indexed));
CHECK(!foo->has_search_index(0));
CHECK(!(spec.get_column_attr(0) & col_attr_Indexed));
foo->add_column(type_Int, "c");
foo->add_search_index(0);
StringIndex* b_index = tf::get_column(*foo, 0).get_search_index();
CHECK_EQUAL(1, b_index->get_ndx_in_parent());
CHECK_EQUAL(3, a_index->get_ndx_in_parent());
df::move_column(*desc, 0, 1);
CHECK(foo->has_search_index(0));
CHECK((spec.get_column_attr(0) & col_attr_Indexed));
CHECK(foo->has_search_index(1));
CHECK((spec.get_column_attr(1) & col_attr_Indexed));
CHECK(!foo->has_search_index(2));
CHECK(!(spec.get_column_attr(2) & col_attr_Indexed));
CHECK_EQUAL(1, a_index->get_ndx_in_parent());
CHECK_EQUAL(3, b_index->get_ndx_in_parent());
df::move_column(*desc, 2, 0);
CHECK(!foo->has_search_index(0));
CHECK(!(spec.get_column_attr(0) & col_attr_Indexed));
CHECK(foo->has_search_index(1));
CHECK((spec.get_column_attr(1) & col_attr_Indexed));
CHECK(foo->has_search_index(2));
CHECK((spec.get_column_attr(2) & col_attr_Indexed));
CHECK_EQUAL(2, a_index->get_ndx_in_parent());
CHECK_EQUAL(4, b_index->get_ndx_in_parent());
df::move_column(*desc, 1, 0);
CHECK(foo->has_search_index(0));
CHECK((spec.get_column_attr(0) & col_attr_Indexed));
CHECK(!foo->has_search_index(1));
CHECK(!(spec.get_column_attr(1) & col_attr_Indexed));
CHECK(foo->has_search_index(2));
CHECK((spec.get_column_attr(2) & col_attr_Indexed));
CHECK_EQUAL(1, a_index->get_ndx_in_parent());
CHECK_EQUAL(4, b_index->get_ndx_in_parent());
}
TEST(Table_NullInEnum)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "second", true);
for (size_t c = 0; c < 100; c++) {
table->insert_empty_row(c);
table->set_string(0, c, "hello");
}
size_t r;
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->optimize();
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->set_string(0, 50, "hello");
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
table->set_string(0, 55, realm::null());
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(2, r);
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(98, r);
table->remove(55);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
}
TEST(Table_SpecAddColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Add a new bool column
table->add_column(type_Bool, "fourth");
CHECK_EQUAL(4, table->get_column_count());
CHECK_EQUAL(false, table->get_bool(3, 0));
// Add a new string column
table->add_column(type_String, "fifth");
CHECK_EQUAL(5, table->get_column_count());
CHECK_EQUAL("", table->get_string(4, 0));
// Add a new table column
table->add_column(type_Table, "sixth");
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(0, table->get_subtable_size(5, 0));
// Add a new mixed column
table->add_column(type_Mixed, "seventh");
CHECK_EQUAL(7, table->get_column_count());
CHECK_EQUAL(0, table->get_mixed(6, 0).get_int());
// Create path to column in sub-table
column_path.clear();
column_path.push_back(2); // third
// Add new int column to sub-table
table->add_subcolumn(column_path, type_Int, "sub_third");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(3, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
}
// Add new table column to sub-table
table->add_subcolumn(column_path, type_Table, "sub_fourth");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
CHECK_EQUAL(0, subtable->get_subtable_size(3, 0));
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
}
// Add new column to new sub-table
column_path.push_back(3); // sub_forth
table->add_subcolumn(column_path, type_String, "first");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
TableRef subsubtable = subtable->get_subtable(3, 0);
CHECK_EQUAL(1, subsubtable->get_column_count());
}
// Add a new mixed column
table->add_column(type_Mixed, "eighth");
CHECK_EQUAL(8, table->get_column_count());
table->set_mixed(7, 0, Mixed::subtable_tag());
TableRef stab = table->get_subtable(7, 0);
stab->add_column(type_Int, "smurf");
stab->insert_empty_row(0);
stab->set_int(0, 0, 1);
stab->insert_empty_row(1);
stab->set_int(0, 1, 2);
CHECK_EQUAL(2, table->get_subtable_size(7, 0));
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_SpecDeleteColumnsBug)
{
TableRef table = Table::create();
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_search_index(0);
table->add_column(type_Int, "age");
table->add_column(type_Bool, "hired");
table->add_column(type_Table, "phones");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(3); // phones
table->add_subcolumn(column_path, type_String, "type");
table->add_subcolumn(column_path, type_String, "number");
// Add rows
table->add_empty_row();
table->set_string(0, 0, "jessica");
table->set_int(1, 0, 22);
table->set_bool(2, 0, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "232-323-3242");
}
table->add_empty_row();
table->set_string(0, 1, "joe");
table->set_int(1, 1, 42);
table->set_bool(2, 1, false);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "work");
phones->set_string(1, 0, "434-434-4343");
}
table->add_empty_row();
table->set_string(0, 1, "jared");
table->set_int(1, 1, 35);
table->set_bool(2, 1, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "342-323-3242");
phones->add_empty_row();
phones->set_string(0, 0, "school");
phones->set_string(1, 0, "434-432-5433");
}
// Add new column
table->add_column(type_Mixed, "extra");
table->set_mixed(4, 0, true);
table->set_mixed(4, 2, "Random string!");
// Remove some columns
table->remove_column(1); // age
table->remove_column(3); // extra
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_Mixed)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Mixed, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Mixed, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
const size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_mixed(1, ndx, true);
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
table.insert_empty_row(1);
table.set_int(0, 1, 43);
table.set_mixed(1, 1, int64_t(12));
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
table.insert_empty_row(2);
table.set_int(0, 2, 100);
table.set_mixed(1, 2, "test");
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
table.insert_empty_row(3);
table.set_int(0, 3, 0);
table.set_mixed(1, 3, OldDateTime(324234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
table.insert_empty_row(4);
table.set_int(0, 4, 43);
table.set_mixed(1, 4, Mixed(BinaryData("binary", 7)));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
table.insert_empty_row(5);
table.set_int(0, 5, 0);
table.set_mixed(1, 5, Mixed::subtable_tag());
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
// Get table from mixed column and add schema and some values
TableRef subtable = table.get_subtable(1, 5);
subtable->add_column(type_String, "name");
subtable->add_column(type_Int, "age");
subtable->insert_empty_row(0);
subtable->set_string(0, 0, "John");
subtable->set_int(1, 0, 40);
// Get same table again and verify values
TableRef subtable2 = table.get_subtable(1, 5);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL("John", subtable2->get_string(0, 0));
CHECK_EQUAL(40, subtable2->get_int(1, 0));
// Insert float, double
table.insert_empty_row(6);
table.set_int(0, 6, 31);
table.set_mixed(1, 6, float(1.123));
table.insert_empty_row(7);
table.set_int(0, 7, 0);
table.set_mixed(1, 7, double(2.234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(31, table.get_int(0, 6));
CHECK_EQUAL(0, table.get_int(0, 7));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(type_Float, table.get_mixed(1, 6).get_type());
CHECK_EQUAL(type_Double, table.get_mixed(1, 7).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
CHECK_EQUAL(float(1.123), table.get_mixed(1, 6).get_float());
CHECK_EQUAL(double(2.234), table.get_mixed(1, 7).get_double());
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_1(TestTableMX, first, Mixed)
} // anonymous namespace
TEST(Table_Mixed2)
{
TestTableMX table;
table.add(int64_t(1));
table.add(true);
table.add(OldDateTime(1234));
table.add("test");
CHECK_EQUAL(type_Int, table[0].first.get_type());
CHECK_EQUAL(type_Bool, table[1].first.get_type());
CHECK_EQUAL(type_OldDateTime, table[2].first.get_type());
CHECK_EQUAL(type_String, table[3].first.get_type());
CHECK_EQUAL(1, table[0].first.get_int());
CHECK_EQUAL(true, table[1].first.get_bool());
CHECK_EQUAL(1234, table[2].first.get_olddatetime());
CHECK_EQUAL("test", table[3].first.get_string());
}
TEST(Table_SubtableSizeAndClear)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "subtab", &subdesc);
table.add_column(type_Mixed, "mixed");
subdesc->add_column(type_Int, "int");
table.insert_empty_row(0);
table.insert_empty_row(1);
Table subtable;
table.set_mixed_subtable(1, 1, &subtable);
CHECK_EQUAL(0, table.get_subtable_size(0, 0)); // Subtable column
CHECK_EQUAL(0, table.get_subtable_size(1, 0)); // Mixed column, bool value
CHECK_EQUAL(0, table.get_subtable_size(1, 1)); // Mixed column, table value
CHECK(table.get_subtable(0, 0)); // Subtable column
CHECK(!table.get_subtable(1, 0)); // Mixed column, bool value, must return nullptr
CHECK(table.get_subtable(1, 1)); // Mixed column, table value
table.set_mixed(1, 0, Mixed::subtable_tag());
table.set_mixed(1, 1, false);
CHECK(table.get_subtable(1, 0));
CHECK(!table.get_subtable(1, 1));
TableRef subtab1 = table.get_subtable(0, 0);
TableRef subtab2 = table.get_subtable(1, 0);
subtab2->add_column(type_Int, "int");
CHECK_EQUAL(0, table.get_subtable_size(1, 0));
CHECK(table.get_subtable(1, 0));
subtab1->insert_empty_row(0);
subtab2->insert_empty_row(0);
CHECK_EQUAL(1, table.get_subtable_size(0, 0));
CHECK_EQUAL(1, table.get_subtable_size(1, 0));
table.clear_subtable(0, 0);
table.clear_subtable(1, 0);
CHECK_EQUAL(0, table.get_subtable_size(0, 0));
CHECK_EQUAL(0, table.get_subtable_size(1, 0));
CHECK(table.get_subtable(1, 0));
}
TEST(Table_LowLevelSubtables)
{
Table table;
std::vector<size_t> column_path;
table.add_column(type_Table, "subtab");
table.add_column(type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
table.add_empty_row(2);
CHECK_EQUAL(2, table.size());
for (int i_1 = 0; i_1 != 2; ++i_1) {
TableRef subtab = table.get_subtable(0, i_1);
subtab->add_empty_row(2 + i_1);
CHECK_EQUAL(2 + i_1, subtab->size());
{
TableRef subsubtab = subtab->get_subtable(0, 0 + i_1);
subsubtab->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 3 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab->clear_subtable(1, 1 + i_1); // Mixed
TableRef subsubtab_mix = subtab->get_subtable(1, 1 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(1 + i_1);
CHECK_EQUAL(1 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 1 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 1 + i_1, bool(subtab->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 0 + i_1 ? 3 + i_1 : 0, subtab->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 1 + i_1 ? 1 + i_1 : 0, subtab->get_subtable_size(1, i_2)); // Mixed
}
table.clear_subtable(1, i_1); // Mixed
TableRef subtab_mix = table.get_subtable(1, i_1);
std::vector<size_t> subcol_path;
subtab_mix->add_column(type_Table, "subtab");
subtab_mix->add_column(type_Mixed, "mixed");
subcol_path.push_back(0);
subtab_mix->add_subcolumn(subcol_path, type_Table, "subtab");
subtab_mix->add_subcolumn(subcol_path, type_Mixed, "mixed");
subtab_mix->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subtab_mix->size());
{
TableRef subsubtab = subtab_mix->get_subtable(0, 1 + i_1);
subsubtab->add_empty_row(7 + i_1);
CHECK_EQUAL(7 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 7 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab_mix->clear_subtable(1, 2 + i_1); // Mixed
TableRef subsubtab_mix = subtab_mix->get_subtable(1, 2 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(5 + i_1);
CHECK_EQUAL(5 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 5 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab_mix->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 2 + i_1, bool(subtab_mix->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 1 + i_1 ? 7 + i_1 : 0, subtab_mix->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 2 + i_1 ? 5 + i_1 : 0, subtab_mix->get_subtable_size(1, i_2)); // Mixed
}
CHECK_EQUAL(true, bool(table.get_subtable(0, i_1)));
CHECK_EQUAL(true, bool(table.get_subtable(1, i_1))); // Mixed
CHECK_EQUAL(2 + i_1, table.get_subtable_size(0, i_1));
CHECK_EQUAL(3 + i_1, table.get_subtable_size(1, i_1)); // Mixed
}
}
namespace {
REALM_TABLE_2(MyTable1, val, Int, val2, Int)
REALM_TABLE_2(MyTable2, val, Int, subtab, Subtable<MyTable1>)
REALM_TABLE_1(MyTable3, subtab, Subtable<MyTable2>)
REALM_TABLE_1(MyTable4, mix, Mixed)
} // anonymous namespace
TEST(Table_HighLevelSubtables)
{
MyTable3 t;
{
MyTable3::Ref r1 = t.get_table_ref();
MyTable3::ConstRef r2 = t.get_table_ref();
MyTable3::ConstRef r3 = r2->get_table_ref();
r3 = t.get_table_ref(); // Also test assigment that converts to const
static_cast<void>(r1);
static_cast<void>(r3);
}
t.add();
const MyTable3& ct = t;
{
MyTable2::Ref s1 = t[0].subtab;
MyTable2::ConstRef s2 = t[0].subtab;
MyTable2::Ref s3 = t[0].subtab->get_table_ref();
MyTable2::ConstRef s4 = t[0].subtab->get_table_ref();
MyTable2::Ref s5 = t.column().subtab[0];
MyTable2::ConstRef s6 = t.column().subtab[0];
MyTable2::Ref s7 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef s8 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef cs1 = ct[0].subtab;
MyTable2::ConstRef cs2 = ct[0].subtab->get_table_ref();
MyTable2::ConstRef cs3 = ct.column().subtab[0];
MyTable2::ConstRef cs4 = ct.column().subtab[0]->get_table_ref();
s1 = t[0].subtab;
s2 = t[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab->add();
{
MyTable1::Ref s1 = t[0].subtab[0].subtab;
MyTable1::ConstRef s2 = t[0].subtab[0].subtab;
MyTable1::Ref s3 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef s4 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::Ref s5 = t.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef s6 = t.column().subtab[0]->column().subtab[0];
MyTable1::Ref s7 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef s8 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef cs1 = ct[0].subtab[0].subtab;
MyTable1::ConstRef cs2 = ct[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef cs3 = ct.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef cs4 = ct.column().subtab[0]->column().subtab[0]->get_table_ref();
s1 = t[0].subtab[0].subtab;
s2 = t[0].subtab[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab[0].val = 1;
CHECK_EQUAL(t[0].subtab[0].val, 1);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 1);
CHECK_EQUAL(t[0].subtab->column().val[0], 1);
CHECK_EQUAL(t.column().subtab[0][0].val, 1);
t.column().subtab[0]->column().val[0] = 2;
CHECK_EQUAL(t[0].subtab[0].val, 2);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 2);
CHECK_EQUAL(t[0].subtab->column().val[0], 2);
CHECK_EQUAL(t.column().subtab[0][0].val, 2);
t[0].subtab->column().val[0] = 3;
CHECK_EQUAL(t[0].subtab[0].val, 3);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 3);
CHECK_EQUAL(t[0].subtab->column().val[0], 3);
CHECK_EQUAL(t.column().subtab[0][0].val, 3);
t.column().subtab[0][0].val = 4;
CHECK_EQUAL(t[0].subtab[0].val, 4);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(t[0].subtab->column().val[0], 4);
CHECK_EQUAL(t.column().subtab[0][0].val, 4);
CHECK_EQUAL(ct[0].subtab[0].val, 4);
CHECK_EQUAL(ct.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(ct[0].subtab->column().val[0], 4);
CHECK_EQUAL(ct.column().subtab[0][0].val, 4);
t[0].subtab[0].subtab->add();
t[0].subtab[0].subtab[0].val = 5;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 5);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 5);
t.column().subtab[0]->column().subtab[0]->column().val[0] = 6;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 6);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 6);
/*
Idea for compile time failure tests:
const MyTable2 t;
#if TEST_INDEX == 0
t[0].val = 7;
#elsif TEST_INDEX == 1
t.column().val[0] = 7;
#elsif TEST_INDEX == 2
t[0].subtab[0].val = 7;
#elsif TEST_INDEX == 3
t[0].subtab->column().val[0] = 7;
#endif
*/
}
TEST(Table_SubtableCopyOnSetAndInsert)
{
MyTable1 t1;
t1.add(7, 8);
MyTable2 t2;
t2.add(9, &t1);
MyTable1::Ref r1 = t2[0].subtab;
CHECK(t1 == *r1);
MyTable4 t4;
t4.add();
t4[0].mix.set_subtable(t2);
MyTable2::Ref r2 = unchecked_cast<MyTable2>(t4[0].mix.get_subtable());
CHECK(t2 == *r2);
}
TEST(Table_SetMethod)
{
MyTable1 t;
t.add(8, 9);
CHECK_EQUAL(t[0].val, 8);
CHECK_EQUAL(t[0].val2, 9);
t.set(0, 2, 4);
CHECK_EQUAL(t[0].val, 2);
CHECK_EQUAL(t[0].val2, 4);
}
namespace {
REALM_TABLE_2(TableDateAndBinary, date, OldDateTime, bin, Binary)
} // anonymous namespace
TEST(Table_DateAndBinary)
{
{
TableDateAndBinary t;
const size_t size = 10;
char data[size];
for (size_t i = 0; i < size; ++i)
data[i] = static_cast<char>(i);
t.add(8, BinaryData(data, size));
CHECK_EQUAL(t[0].date, 8);
CHECK_EQUAL(t[0].bin.size(), size);
CHECK(std::equal(t[0].bin.data(), t[0].bin.data() + size, data));
}
// Test that 64-bit dates are preserved
{
TableDateAndBinary t;
int64_t date = std::numeric_limits<int64_t>::max() - 400;
t.add(date, BinaryData(""));
CHECK_EQUAL(t[0].date.get().get_olddatetime(), date);
}
}
// Test for a specific bug found: Calling clear on a group with a table with a subtable
TEST(Table_ClearWithSubtableAndGroup)
{
Group group;
TableRef table = group.add_table("test");
DescriptorRef sub_1;
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_column(type_Table, "sub", &sub_1);
sub_1->add_column(type_Int, "num");
CHECK_EQUAL(2, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_string(0, 0, "Foo");
CHECK_EQUAL(0, table->get_subtable_size(1, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(1, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 123);
CHECK_EQUAL(123, subtable->get_int(0, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(1, 0));
table->clear();
}
// set a subtable in an already exisitng row by providing an existing subtable as the example to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample2?
TEST(Table_SetSubTableByExample1)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// create a freestanding table to be used as a source by set_subtable
Table sub = Table();
sub.add_column(type_Int, "sub_first");
sub.add_column(type_String, "sub_second");
sub.add_empty_row();
sub.set_int(0, 0, 42);
sub.set_string(1, 0, "forty two");
sub.add_empty_row();
sub.set_int(0, 1, 3);
sub.set_string(1, 1, "PI");
// Get the sub-table back for inspection
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
// add a subtable into the row, resembling the sub we just created
table->set_subtable(2, 0, &sub);
TableRef subtable2 = table->get_subtable(2, 0);
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1, 1));
}
}
// In the tableview class, set a subtable in an already exisitng row by providing an existing subtable as the example
// to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample1?
TEST(Table_SetSubTableByExample2)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add two rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->insert_empty_row(1);
table->set_int(0, 1, 8);
table->set_string(1, 1, "Hi!, Hello?");
Table sub = Table();
sub.add_column(type_Int, "sub_first");
sub.add_column(type_String, "sub_second");
sub.add_empty_row();
sub.set_int(0, 0, 42);
sub.set_string(1, 0, "forty two");
sub.add_empty_row();
sub.set_int(0, 1, 3);
sub.set_string(1, 1, "PI");
// create a tableview with the table as source
TableView view = table->find_all_int(0, 8); // select the second of the two rows
// Verify the sub table is empty
{
TableRef subtable = view.get_subtable(2, 0);
CHECK(subtable->is_empty());
// add a subtable into the second table row (first view row), resembling the sub we just created
view.set_subtable(2, 0, &sub);
TableRef subtable2 = view.get_subtable(2, 0); // fetch back the subtable from the view
CHECK_EQUAL(false, subtable->is_empty());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1, 1));
TableRef subtable3 = table->get_subtable(2, 1); // fetch back the subtable from the table.
CHECK_EQUAL(42, subtable3->get_int(0, 0));
CHECK_EQUAL("forty two", subtable3->get_string(1, 0));
CHECK_EQUAL(3, subtable3->get_int(0, 1));
CHECK_EQUAL("PI", subtable3->get_string(1, 1));
}
}
TEST(Table_HasSharedSpec)
{
MyTable2 table1;
CHECK(!table1.has_shared_type());
Group g;
MyTable2::Ref table2 = g.add_table<MyTable2>("foo");
CHECK(!table2->has_shared_type());
table2->add();
CHECK(table2[0].subtab->has_shared_type());
// Subtable in mixed column
TestTableMX::Ref table3 = g.add_table<TestTableMX>("bar");
CHECK(!table3->has_shared_type());
table3->add();
table3[0].first.set_subtable<MyTable2>();
MyTable2::Ref table4 = table3[0].first.get_subtable<MyTable2>();
CHECK(table4);
CHECK(!table4->has_shared_type());
table4->add();
CHECK(!table4->has_shared_type());
CHECK(table4[0].subtab->has_shared_type());
}
namespace {
REALM_TABLE_3(TableAgg, c_int, Int, c_float, Float, c_double, Double)
// TODO: Bool? OldDateTime
} // anonymous namespace
#if TEST_DURATION > 0
#define TBL_SIZE REALM_MAX_BPNODE_SIZE * 10
#else
#define TBL_SIZE 10
#endif
TEST(Table_Aggregates)
{
TableAgg table;
int64_t i_sum = 0;
double f_sum = 0;
double d_sum = 0;
for (int i = 0; i < TBL_SIZE; i++) {
table.add(5987654, 4.0f, 3.0);
i_sum += 5987654;
f_sum += 4.0f;
d_sum += 3.0;
}
table.add(1, 1.1f, 1.2);
table.add(987654321, 11.0f, 12.0);
table.add(5, 4.0f, 3.0);
i_sum += 1 + 987654321 + 5;
f_sum += double(1.1f) + double(11.0f) + double(4.0f);
d_sum += 1.2 + 12.0 + 3.0;
double size = TBL_SIZE + 3;
double epsilon = std::numeric_limits<double>::epsilon();
// minimum
CHECK_EQUAL(1, table.column().c_int.minimum());
CHECK_EQUAL(1.1f, table.column().c_float.minimum());
CHECK_EQUAL(1.2, table.column().c_double.minimum());
// maximum
CHECK_EQUAL(987654321, table.column().c_int.maximum());
CHECK_EQUAL(11.0f, table.column().c_float.maximum());
CHECK_EQUAL(12.0, table.column().c_double.maximum());
// sum
CHECK_APPROXIMATELY_EQUAL(double(i_sum), double(table.column().c_int.sum()), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum, table.column().c_float.sum(), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum, table.column().c_double.sum(), 10 * epsilon);
// average
CHECK_APPROXIMATELY_EQUAL(i_sum / size, table.column().c_int.average(), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum / size, table.column().c_float.average(), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum / size, table.column().c_double.average(), 10 * epsilon);
}
namespace {
REALM_TABLE_1(TableAgg2, c_count, Int)
} // anonymous namespace
TEST(Table_Aggregates2)
{
TableAgg2 table;
int c = -420;
int s = 0;
while (c < -20) {
table.add(c);
s += c;
c++;
}
CHECK_EQUAL(-420, table.column().c_count.minimum());
CHECK_EQUAL(-21, table.column().c_count.maximum());
CHECK_EQUAL(s, table.column().c_count.sum());
}
// Test Table methods max, min, avg, sum, on both nullable and non-nullable columns
TEST(Table_Aggregates3)
{
bool nullable = false;
for (int i = 0; i < 2; i++) {
// First we test everything with columns being nullable and with each column having at least 1 null
// Then we test everything with non-nullable columns where the null entries will instead be just
// 0, 0.0, etc.
nullable = (i == 1);
Group g;
TableRef table = g.add_table("Inventory");
table->insert_column(0, type_Int, "Price", nullable);
table->insert_column(1, type_Float, "Shipping", nullable);
table->insert_column(2, type_Double, "Rating", nullable);
table->insert_column(3, type_OldDateTime, "Delivery date", nullable);
table->insert_column(4, type_Timestamp, "Delivery date 2", nullable);
table->add_empty_row(3);
table->set_int(0, 0, 1);
// table->set_null(0, 1);
table->set_int(0, 2, 3);
// table->set_null(1, 0);
// table->set_null(1, 1);
table->set_float(1, 2, 30.f);
table->set_double(2, 0, 1.1);
table->set_double(2, 1, 2.2);
// table->set_null(2, 2);
table->set_olddatetime(3, 0, OldDateTime(2016, 2, 2));
// table->set_null(3, 1);
table->set_olddatetime(3, 2, OldDateTime(2016, 6, 6));
table->set_timestamp(4, 0, Timestamp(2, 2));
// table->set_null(4, 1);
table->set_timestamp(4, 2, Timestamp(6, 6));
size_t count;
size_t pos;
if (nullable) {
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0), 3);
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1), 30.f);
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2), 2.2);
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_olddatetime(3), OldDateTime(2016, 6, 6));
CHECK_EQUAL(table->maximum_olddatetime(3, &pos), OldDateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_timestamp(4), Timestamp(6, 6));
CHECK_EQUAL(table->maximum_timestamp(4, &pos), Timestamp(6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0), 1);
CHECK_EQUAL(table->minimum_int(0, &pos), 1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_float(1), 30.f);
CHECK_EQUAL(table->minimum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_double(2), 1.1);
CHECK_EQUAL(table->minimum_double(2, &pos), 1.1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_olddatetime(3), OldDateTime(2016, 2, 2));
CHECK_EQUAL(table->minimum_olddatetime(3, &pos), OldDateTime(2016, 2, 2));
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_timestamp(4), Timestamp(2, 2));
CHECK_EQUAL(table->minimum_timestamp(4, &pos), Timestamp(2, 2));
CHECK_EQUAL(pos, 0);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0), (1 + 3) / 2., 0.01);
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3) / 2., 0.01);
CHECK_EQUAL(count, 2);
count = 123;
CHECK_EQUAL(table->average_float(1), 30.f);
CHECK_EQUAL(table->average_float(1, &count), 30.f);
CHECK_EQUAL(count, 1);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2), (1.1 + 2.2) / 2., 0.01);
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2) / 2., 0.01);
CHECK_EQUAL(count, 2);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
else { // not nullable
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_olddatetime(3, &pos), OldDateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_timestamp(4, &pos), Timestamp(6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0, &pos), 0);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->minimum_float(1, &pos), 0.f);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_double(2, &pos), 0.);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_olddatetime(3, &pos), OldDateTime(0));
CHECK_EQUAL(pos, 1);
pos = 123;
// Timestamp(0, 0) is default value for non-nullable column
CHECK_EQUAL(table->minimum_timestamp(4, &pos), Timestamp(0, 0));
CHECK_EQUAL(pos, 1);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3 + 0) / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_float(1, &count), 30.f / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2 + 0.) / 3., 0.01);
CHECK_EQUAL(count, 3);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
}
}
TEST(Table_EmptyMinmax)
{
Group g;
TableRef table = g.add_table("");
table->add_column(type_Timestamp, "");
size_t min_index;
Timestamp min_ts = table->minimum_timestamp(0, &min_index);
CHECK_EQUAL(min_index, realm::npos);
CHECK(min_ts.is_null());
size_t max_index;
Timestamp max_ts = table->maximum_timestamp(0, &max_index);
CHECK_EQUAL(max_index, realm::npos);
CHECK(max_ts.is_null());
}
TEST(Table_LanguageBindings)
{
Table* table = LangBindHelper::new_table();
CHECK(table->is_attached());
table->add_column(type_Int, "i");
table->insert_empty_row(0);
table->set_int(0, 0, 10);
table->insert_empty_row(1);
table->set_int(0, 1, 12);
Table* table2 = LangBindHelper::copy_table(*table);
CHECK(table2->is_attached());
CHECK(*table == *table2);
LangBindHelper::unbind_table_ptr(table);
LangBindHelper::unbind_table_ptr(table2);
}
TEST(Table_MultipleColumn)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "first");
CHECK_EQUAL(table.get_column_count(), 2);
CHECK_EQUAL(table.get_column_index("first"), 0);
}
TEST(Table_FormerLeakCase)
{
Table sub;
sub.add_column(type_Int, "a");
Table root;
DescriptorRef subdesc;
root.add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "a");
root.add_empty_row(1);
root.set_subtable(0, 0, &sub);
root.set_subtable(0, 0, nullptr);
}
namespace {
REALM_TABLE_3(TablePivotAgg, sex, String, age, Int, hired, Bool)
} // anonymous namespace
TEST(Table_Pivot)
{
size_t count = 1717;
TablePivotAgg table;
int64_t age_sum[2] = {0, 0};
int64_t age_cnt[2] = {0, 0};
int64_t age_min[2];
int64_t age_max[2];
double age_avg[2];
for (size_t i = 0; i < count; ++i) {
size_t sex = i % 2;
int64_t age = 3 + (i % 117);
table.add((sex == 0) ? "Male" : "Female", age, true);
age_sum[sex] += age;
age_cnt[sex] += 1;
if ((i < 2) || age < age_min[sex])
age_min[sex] = age;
if ((i < 2) || age > age_max[sex])
age_max[sex] = age;
}
for (size_t sex = 0; sex < 2; ++sex) {
age_avg[sex] = double(age_sum[sex]) / double(age_cnt[sex]);
}
for (int i = 0; i < 2; ++i) {
Table result_count;
table.aggregate(0, 1, Table::aggr_count, result_count);
CHECK_EQUAL(2, result_count.get_column_count());
CHECK_EQUAL(2, result_count.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_cnt[sex], result_count.get_int(1, sex));
}
Table result_sum;
table.aggregate(0, 1, Table::aggr_sum, result_sum);
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_sum[sex], result_sum.get_int(1, sex));
}
Table result_avg;
table.aggregate(0, 1, Table::aggr_avg, result_avg);
if ((false)) {
std::ostringstream ss;
result_avg.to_string(ss);
std::cerr << "\nMax:\n" << ss.str();
}
CHECK_EQUAL(2, result_avg.get_column_count());
CHECK_EQUAL(2, result_avg.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_avg[sex], result_avg.get_double(1, sex));
}
Table result_min;
table.aggregate(0, 1, Table::aggr_min, result_min);
CHECK_EQUAL(2, result_min.get_column_count());
CHECK_EQUAL(2, result_min.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_min[sex], result_min.get_int(1, sex));
}
Table result_max;
table.aggregate(0, 1, Table::aggr_max, result_max);
CHECK_EQUAL(2, result_max.get_column_count());
CHECK_EQUAL(2, result_max.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_max[sex], result_max.get_int(1, sex));
}
// Test with enumerated strings in second loop
table.optimize();
}
}
namespace {
void compare_table_with_slice(TestContext& test_context, const Table& table, const Table& slice, size_t offset,
size_t size)
{
ConstDescriptorRef table_desc = table.get_descriptor();
ConstDescriptorRef slice_desc = slice.get_descriptor();
CHECK(*table_desc == *slice_desc);
if (*table_desc != *slice_desc)
return;
size_t num_cols = table.get_column_count();
for (size_t col_i = 0; col_i != num_cols; ++col_i) {
DataType type = table.get_column_type(col_i);
switch (type) {
case type_Int:
case type_Link:
for (size_t i = 0; i != size; ++i) {
int_fast64_t v_1 = table.get_int(col_i, offset + i);
int_fast64_t v_2 = slice.get_int(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Bool:
for (size_t i = 0; i != size; ++i) {
bool v_1 = table.get_bool(col_i, offset + i);
bool v_2 = slice.get_bool(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Float:
for (size_t i = 0; i != size; ++i) {
float v_1 = table.get_float(col_i, offset + i);
float v_2 = slice.get_float(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Double:
for (size_t i = 0; i != size; ++i) {
double v_1 = table.get_double(col_i, offset + i);
double v_2 = slice.get_double(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_String:
for (size_t i = 0; i != size; ++i) {
StringData v_1 = table.get_string(col_i, offset + i);
StringData v_2 = slice.get_string(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Binary:
for (size_t i = 0; i != size; ++i) {
BinaryData v_1 = table.get_binary(col_i, offset + i);
BinaryData v_2 = slice.get_binary(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_OldDateTime:
for (size_t i = 0; i != size; ++i) {
OldDateTime v_1 = table.get_olddatetime(col_i, offset + i);
OldDateTime v_2 = slice.get_olddatetime(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Timestamp:
for (size_t i = 0; i != size; ++i) {
Timestamp v_1 = table.get_timestamp(col_i, offset + i);
Timestamp v_2 = slice.get_timestamp(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Table:
for (size_t i = 0; i != size; ++i) {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
}
break;
case type_Mixed:
for (size_t i = 0; i != size; ++i) {
Mixed v_1 = table.get_mixed(col_i, offset + i);
Mixed v_2 = slice.get_mixed(col_i, i);
CHECK_EQUAL(v_1.get_type(), v_2.get_type());
if (v_1.get_type() == v_2.get_type()) {
switch (v_1.get_type()) {
case type_Int:
CHECK_EQUAL(v_1.get_int(), v_2.get_int());
break;
case type_Bool:
CHECK_EQUAL(v_1.get_bool(), v_2.get_bool());
break;
case type_Float:
CHECK_EQUAL(v_1.get_float(), v_2.get_float());
break;
case type_Double:
CHECK_EQUAL(v_1.get_double(), v_2.get_double());
break;
case type_String:
CHECK_EQUAL(v_1.get_string(), v_2.get_string());
break;
case type_Binary:
CHECK_EQUAL(v_1.get_binary(), v_2.get_binary());
break;
case type_OldDateTime:
CHECK_EQUAL(v_1.get_olddatetime(), v_2.get_olddatetime());
break;
case type_Timestamp:
CHECK_EQUAL(v_1.get_timestamp(), v_2.get_timestamp());
break;
case type_Table: {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
break;
}
case type_Mixed:
case type_Link:
case type_LinkList:
REALM_ASSERT(false);
}
}
}
break;
case type_LinkList:
break;
}
}
}
void test_write_slice_name(TestContext& test_context, const Table& table, StringData expect_name, bool override_name)
{
size_t offset = 0, size = 0;
std::ostringstream out;
if (override_name) {
table.write(out, offset, size, expect_name);
}
else {
table.write(out, offset, size);
}
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table(expect_name);
CHECK(slice);
}
void test_write_slice_contents(TestContext& test_context, const Table& table, size_t offset, size_t size)
{
std::ostringstream out;
table.write(out, offset, size);
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table("test");
CHECK(slice);
if (slice) {
size_t remaining_size = table.size() - offset;
size_t size_2 = size;
if (size_2 > remaining_size)
size_2 = remaining_size;
CHECK_EQUAL(size_2, slice->size());
if (size_2 == slice->size())
compare_table_with_slice(test_context, table, *slice, offset, size_2);
}
}
} // anonymous namespace
TEST(Table_WriteSlice)
{
// check that the name of the written table is as expected
{
Table table;
test_write_slice_name(test_context, table, "", false);
test_write_slice_name(test_context, table, "foo", true); // Override
test_write_slice_name(test_context, table, "", true); // Override
}
{
Group group;
TableRef table = group.add_table("test");
test_write_slice_name(test_context, *table, "test", false);
test_write_slice_name(test_context, *table, "foo", true); // Override
test_write_slice_name(test_context, *table, "", true); // Override
}
// Run through a 3-D matrix of table sizes, slice offsets, and
// slice sizes. Each test involves a table with columns of each
// possible type.
#if TEST_DURATION > 0
int table_sizes[] = {0, 1, 2, 3, 5, 9, 27, 81, 82, 243, 729, 2187, 6561};
#else
int table_sizes[] = {0, 1, 2, 3, 5, 9, 27, 81, 82, 243, 729, 2187};
#endif
int num_sizes = sizeof table_sizes / sizeof *table_sizes;
for (int table_size_i = 0; table_size_i != num_sizes; ++table_size_i) {
int table_size = table_sizes[table_size_i];
Group group;
TableRef table = group.add_table("test");
bool fixed_subtab_sizes = true;
setup_multi_table(*table, table_size, 1, fixed_subtab_sizes);
for (int offset_i = 0; offset_i != num_sizes; ++offset_i) {
int offset = table_sizes[offset_i];
if (offset > table_size)
break;
for (int size_i = 0; size_i != num_sizes; ++size_i) {
int size = table_sizes[size_i];
// This also checks that the range can extend beyond
// end of table
test_write_slice_contents(test_context, *table, offset, size);
if (offset + size > table_size)
break;
}
}
}
}
TEST(Table_Parent)
{
TableRef table = Table::create();
CHECK_EQUAL(TableRef(), table->get_parent_table());
CHECK_EQUAL(realm::npos, table->get_parent_row_index()); // Not a subtable
CHECK_EQUAL(realm::npos, table->get_index_in_group()); // Not a group-level table
DescriptorRef subdesc;
table->add_column(type_Table, "", &subdesc);
table->add_column(type_Mixed, "");
subdesc->add_column(type_Int, "");
table->add_empty_row(2);
table->set_mixed(1, 0, Mixed::subtable_tag());
table->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab;
size_t column_ndx = 0;
subtab = table->get_subtable(0, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after new
// column is insert.
table->insert_column(0, type_Int, "");
subtab = table->get_subtable(1, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(2, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(2, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after inserted
// column is removed.
table->remove_column(0);
subtab = table->get_subtable(0, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
}
TEST(Table_RegularSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
DescriptorRef subdesc;
parent->add_column(type_Table, "a", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
TableRef subtab_0_0 = parent->get_subtable(0, 0);
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
parent->add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
subtab_0_0->add_empty_row();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
TableRef subtab_0_1 = parent->get_subtable(0, 1);
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
TableRef subtab_1_0 = parent->get_subtable(1, 0);
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
TableRef subtab_1_1 = parent->get_subtable(1, 1);
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Float, "f");
subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int(0, 0, 10000);
subtab_0_0->set_float(1, 0, 10010.0f);
subtab_1_1->set_int(0, 0, 11100);
subtab_1_1->set_double(1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11100, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double(1, 0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int(0, 0, 10001);
subtab_0_0->set_float(1, 0, 10011.0f);
subtab_1_1->set_int(0, 0, 11101);
subtab_1_1->set_double(1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11101, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
subtab_0_0->set_int(0, 0, 10002);
subtab_0_0->set_float(1, 0, 10012.0f);
subtab_1_1->set_int(0, 0, 11102);
subtab_1_1->set_double(1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11102, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int(0, 0, 10003);
subtab_0_0->set_float(1, 0, 10013.0f);
subtab_1_1->set_int(0, 0, 11103);
subtab_1_1->set_double(1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11103, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10004);
subtab_0_0->set_float(1, 0, 10014.0f);
subtab_1_1->set_int(0, 0, 11104);
subtab_1_1->set_double(1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11104, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int(0, 0, 10005);
subtab_0_0->set_float(1, 0, 10015.0f);
subtab_1_1->set_int(0, 0, 11105);
subtab_1_1->set_double(1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11105, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10006);
subtab_0_0->set_float(1, 0, 10016.0f);
subtab_1_1->set_int(0, 0, 11106);
subtab_1_1->set_double(1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11106, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int(0, 0, 10007);
subtab_0_0->set_float(1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
parent->remove_column(1);
subtab_0_0->set_int(0, 0, 10008);
subtab_0_0->set_float(1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
// Clear subtable
parent->clear_subtable(0, 0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Table, "c", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0, 0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Table, "d", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0, 0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0, 0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_MixedSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_column(type_Int, "x");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
subtab_0_0->add_empty_row();
parent->add_column(type_Mixed, "b");
parent->set_mixed(1, 0, Mixed::subtable_tag());
TableRef subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_0->add_column(type_Int, "x");
parent->add_empty_row();
parent->set_mixed(0, 1, Mixed::subtable_tag());
TableRef subtab_0_1 = parent->get_subtable(0, 1);
subtab_0_1->add_column(type_Int, "x");
parent->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_column(type_Int, "x");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subtab_0_0->add_column(type_Float, "f");
subtab_0_1->add_column(type_Float, "f");
subtab_1_0->add_column(type_Double, "d");
subtab_1_1->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int(0, 0, 10000);
subtab_0_0->set_float(1, 0, 10010.0f);
subtab_1_1->set_int(0, 0, 11100);
subtab_1_1->set_double(1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11100, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double(1, 0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int(0, 0, 10001);
subtab_0_0->set_float(1, 0, 10011.0f);
subtab_1_1->set_int(0, 0, 11101);
subtab_1_1->set_double(1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11101, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
parent->set_mixed(3, 2, "Lopadotemachoselachogaleokranioleipsanodrimhypotrimmatosilphio"
"paraomelitokatakechymenokichlepikossyphophattoperisteralektryonopte"
"kephalliokigklopeleiolagoiosiraiobaphetraganopterygon");
subtab_0_0->set_int(0, 0, 10002);
subtab_0_0->set_float(1, 0, 10012.0f);
subtab_1_1->set_int(0, 0, 11102);
subtab_1_1->set_double(1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11102, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int(0, 0, 10003);
subtab_0_0->set_float(1, 0, 10013.0f);
subtab_1_1->set_int(0, 0, 11103);
subtab_1_1->set_double(1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11103, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10004);
subtab_0_0->set_float(1, 0, 10014.0f);
subtab_1_1->set_int(0, 0, 11104);
subtab_1_1->set_double(1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11104, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int(0, 0, 10005);
subtab_0_0->set_float(1, 0, 10015.0f);
subtab_1_1->set_int(0, 0, 11105);
subtab_1_1->set_double(1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11105, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10006);
subtab_0_0->set_float(1, 0, 10016.0f);
subtab_1_1->set_int(0, 0, 11106);
subtab_1_1->set_double(1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11106, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int(0, 0, 10007);
subtab_0_0->set_float(1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
parent->remove_column(1);
subtab_0_0->set_int(0, 0, 10008);
subtab_0_0->set_float(1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
// Remove subtable
parent->clear_subtable(0, 0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(!subtab_0_0->is_attached());
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Mixed, "c");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
CHECK(subtab_0_0);
CHECK(subtab_0_1);
CHECK(subtab_1_0);
CHECK(subtab_1_1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0, 0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Mixed, "d");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0, 0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0, 0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_RowAccessor)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Int, "int");
table.add_column(type_Bool, "bool");
table.add_column(type_Float, "");
table.add_column(type_Double, "");
table.add_column(type_String, "");
table.add_column(type_Binary, "", true);
table.add_column(type_OldDateTime, "");
table.add_column(type_Table, "", &subdesc);
table.add_column(type_Mixed, "");
subdesc->add_column(type_Int, "i");
table.add_empty_row(2);
BinaryData bin("bin", 3);
Table empty_subtab;
empty_subtab.add_column(type_Int, "i");
Table one_subtab;
one_subtab.add_column(type_Int, "i");
one_subtab.add_empty_row(1);
one_subtab.set_int(0, 0, 19);
Table two_subtab;
two_subtab.add_column(type_Int, "i");
two_subtab.add_empty_row(1);
two_subtab.set_int(0, 0, 29);
table.set_int(0, 1, 4923);
table.set_bool(1, 1, true);
table.set_float(2, 1, 5298.0f);
table.set_double(3, 1, 2169.0);
table.set_string(4, 1, "str");
table.set_binary(5, 1, bin);
table.set_olddatetime(6, 1, 7739);
table.set_subtable(7, 1, &one_subtab);
table.set_mixed(8, 1, Mixed("mix"));
// Check getters for `RowExpr`
{
CHECK_EQUAL(9, table[0].get_column_count());
CHECK_EQUAL(type_Int, table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, table[0].get_column_type(1));
CHECK_EQUAL("int", table[0].get_column_name(0));
CHECK_EQUAL("bool", table[0].get_column_name(1));
CHECK_EQUAL(0, table[0].get_column_index("int"));
CHECK_EQUAL(1, table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), table[0].get_int(0));
CHECK_EQUAL(bool(), table[0].get_bool(1));
CHECK_EQUAL(float(), table[0].get_float(2));
CHECK_EQUAL(double(), table[0].get_double(3));
CHECK_EQUAL(StringData(""), table[0].get_string(4));
CHECK_EQUAL(BinaryData(), table[0].get_binary(5));
CHECK_EQUAL(OldDateTime(), table[0].get_olddatetime(6));
CHECK_EQUAL(0, table[0].get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), table[0].get_mixed(8));
CHECK_EQUAL(type_Int, table[0].get_mixed_type(8));
CHECK_EQUAL(4923, table[1].get_int(0));
CHECK_EQUAL(true, table[1].get_bool(1));
CHECK_EQUAL(5298.0f, table[1].get_float(2));
CHECK_EQUAL(2169.0, table[1].get_double(3));
CHECK_EQUAL("str", table[1].get_string(4));
CHECK_EQUAL(bin, table[1].get_binary(5));
CHECK_EQUAL(OldDateTime(7739), table[1].get_olddatetime(6));
CHECK_EQUAL(1, table[1].get_subtable_size(7));
CHECK_EQUAL("mix", table[1].get_mixed(8));
CHECK_EQUAL(type_String, table[1].get_mixed_type(8));
TableRef subtab_0 = table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRowExpr`
{
const Table& const_table = table;
CHECK_EQUAL(9, const_table[0].get_column_count());
CHECK_EQUAL(type_Int, const_table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, const_table[0].get_column_type(1));
CHECK_EQUAL("int", const_table[0].get_column_name(0));
CHECK_EQUAL("bool", const_table[0].get_column_name(1));
CHECK_EQUAL(0, const_table[0].get_column_index("int"));
CHECK_EQUAL(1, const_table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_int(0));
CHECK_EQUAL(bool(), const_table[0].get_bool(1));
CHECK_EQUAL(float(), const_table[0].get_float(2));
CHECK_EQUAL(double(), const_table[0].get_double(3));
CHECK_EQUAL(StringData(""), const_table[0].get_string(4));
CHECK_EQUAL(BinaryData(), const_table[0].get_binary(5));
CHECK_EQUAL(OldDateTime(), const_table[0].get_olddatetime(6));
CHECK_EQUAL(0, const_table[0].get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_mixed(8));
CHECK_EQUAL(type_Int, const_table[0].get_mixed_type(8));
CHECK_EQUAL(4923, const_table[1].get_int(0));
CHECK_EQUAL(true, const_table[1].get_bool(1));
CHECK_EQUAL(5298.0f, const_table[1].get_float(2));
CHECK_EQUAL(2169.0, const_table[1].get_double(3));
CHECK_EQUAL("str", const_table[1].get_string(4));
CHECK_EQUAL(bin, const_table[1].get_binary(5));
CHECK_EQUAL(OldDateTime(7739), const_table[1].get_olddatetime(6));
CHECK_EQUAL(1, const_table[1].get_subtable_size(7));
CHECK_EQUAL("mix", const_table[1].get_mixed(8));
CHECK_EQUAL(type_String, const_table[1].get_mixed_type(8));
ConstTableRef subtab_0 = const_table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = const_table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(9, row_0.get_column_count());
CHECK_EQUAL(type_Int, row_0.get_column_type(0));
CHECK_EQUAL(type_Bool, row_0.get_column_type(1));
CHECK_EQUAL("int", row_0.get_column_name(0));
CHECK_EQUAL("bool", row_0.get_column_name(1));
CHECK_EQUAL(0, row_0.get_column_index("int"));
CHECK_EQUAL(1, row_0.get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
TableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const Row`
{
const Row row_0 = table[0];
const Row row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRow`
{
ConstRow row_0 = table[0];
ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const ConstRow` (double constness)
{
const ConstRow row_0 = table[0];
const ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check setters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
row_0.set_int(0, 5651);
row_0.set_bool(1, true);
row_0.set_float(2, 8397.0f);
row_0.set_double(3, 1937.0);
row_0.set_string(4, "foo");
row_0.set_binary(5, bin);
row_0.set_olddatetime(6, OldDateTime(9992));
row_0.set_subtable(7, &one_subtab);
row_0.set_mixed(8, Mixed(3637.0f));
row_1.set_int(0, int_fast64_t());
row_1.set_bool(1, bool());
row_1.set_float(2, float());
row_1.set_double(3, double());
row_1.set_string(4, StringData(""));
row_1.set_binary(5, BinaryData());
row_1.set_olddatetime(6, OldDateTime());
row_1.set_subtable(7, nullptr);
row_1.set_mixed(8, Mixed());
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(5651, table.get_int(0, 0));
CHECK_EQUAL(true, table.get_bool(1, 0));
CHECK_EQUAL(8397.0f, table.get_float(2, 0));
CHECK_EQUAL(1937.0, table.get_double(3, 0));
CHECK_EQUAL("foo", table.get_string(4, 0));
CHECK_EQUAL(bin, table.get_binary(5, 0));
CHECK_EQUAL(OldDateTime(9992), table.get_olddatetime(6, 0));
CHECK_EQUAL(3637.0f, table.get_mixed(8, 0));
CHECK_EQUAL(int_fast64_t(), table.get_int(0, 1));
CHECK_EQUAL(bool(), table.get_bool(1, 1));
CHECK_EQUAL(float(), table.get_float(2, 1));
CHECK_EQUAL(double(), table.get_double(3, 1));
CHECK_EQUAL(StringData(""), table.get_string(4, 1));
CHECK_EQUAL(BinaryData(), table.get_binary(5, 1));
CHECK_EQUAL(OldDateTime(), table.get_olddatetime(6, 1));
CHECK_EQUAL(int_fast64_t(), table.get_mixed(8, 1));
TableRef subtab_0 = table.get_subtable(7, 0);
CHECK_EQUAL(19, subtab_0->get_int(0, 0));
CHECK(*subtab_0 == one_subtab);
TableRef subtab_1 = table.get_subtable(7, 1);
CHECK(*subtab_1 == empty_subtab);
row_0.set_mixed_subtable(8, 0);
row_1.set_mixed_subtable(8, &two_subtab);
subtab_0 = table.get_subtable(8, 0);
subtab_1 = table.get_subtable(8, 1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK(*subtab_0 == Table());
CHECK_EQUAL(29, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == two_subtab);
}
// Check setters for `RowExpr`
{
table[0].set_int(0, int_fast64_t());
table[0].set_bool(1, bool());
table[0].set_float(2, float());
table[0].set_double(3, double());
table[0].set_string(4, StringData(""));
table[0].set_binary(5, BinaryData());
table[0].set_olddatetime(6, OldDateTime());
table[0].set_subtable(7, nullptr);
table[0].set_mixed(8, Mixed());
table[1].set_int(0, 5651);
table[1].set_bool(1, true);
table[1].set_float(2, 8397.0f);
table[1].set_double(3, 1937.0);
table[1].set_string(4, "foo");
table[1].set_binary(5, bin);
table[1].set_olddatetime(6, OldDateTime(9992));
table[1].set_subtable(7, &one_subtab);
table[1].set_mixed(8, Mixed(3637.0f));
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(int_fast64_t(), table.get_int(0, 0));
CHECK_EQUAL(bool(), table.get_bool(1, 0));
CHECK_EQUAL(float(), table.get_float(2, 0));
CHECK_EQUAL(double(), table.get_double(3, 0));
CHECK_EQUAL(StringData(""), table.get_string(4, 0));
CHECK_EQUAL(BinaryData(), table.get_binary(5, 0));
CHECK_EQUAL(OldDateTime(), table.get_olddatetime(6, 0));
CHECK_EQUAL(int_fast64_t(), table.get_mixed(8, 0));
CHECK_EQUAL(5651, table.get_int(0, 1));
CHECK_EQUAL(true, table.get_bool(1, 1));
CHECK_EQUAL(8397.0f, table.get_float(2, 1));
CHECK_EQUAL(1937.0, table.get_double(3, 1));
CHECK_EQUAL("foo", table.get_string(4, 1));
CHECK_EQUAL(bin, table.get_binary(5, 1));
CHECK_EQUAL(OldDateTime(9992), table.get_olddatetime(6, 1));
CHECK_EQUAL(3637.0f, table.get_mixed(8, 1));
TableRef subtab_0 = table.get_subtable(7, 0);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table.get_subtable(7, 1);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
table[0].set_mixed_subtable(8, &two_subtab);
table[1].set_mixed_subtable(8, 0);
subtab_0 = table.get_subtable(8, 0);
subtab_1 = table.get_subtable(8, 1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK_EQUAL(29, subtab_0->get_int(0, 0));
CHECK(*subtab_0 == two_subtab);
CHECK(*subtab_1 == Table());
}
// Check that we can also create ConstRow's from `const Table`
{
const Table& const_table = table;
ConstRow row_0 = const_table[0];
ConstRow row_1 = const_table[1];
CHECK_EQUAL(0, row_0.get_int(0));
CHECK_EQUAL(5651, row_1.get_int(0));
}
// Check that we can get the table and the row index from a Row
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(&table, row_0.get_table());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
}
}
TEST(Table_RowAccessorLinks)
{
Group group;
TableRef target_table = group.add_table("target");
target_table->add_column(type_Int, "");
target_table->add_empty_row(16);
TableRef origin_table = group.add_table("origin");
origin_table->add_column_link(type_Link, "", *target_table);
origin_table->add_column_link(type_LinkList, "", *target_table);
origin_table->add_empty_row(2);
Row source_row_1 = origin_table->get(0);
Row source_row_2 = origin_table->get(1);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
// Set links
source_row_1.set_link(0, 7);
source_row_2.set_link(0, 13);
CHECK(!source_row_1.is_null_link(0));
CHECK(!source_row_2.is_null_link(0));
CHECK_EQUAL(7, source_row_1.get_link(0));
CHECK_EQUAL(13, source_row_2.get_link(0));
CHECK_EQUAL(1, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(7).get_backlink(*origin_table, 0, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink(*origin_table, 0, 0));
// Nullify links
source_row_1.nullify_link(0);
source_row_2.nullify_link(0);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
// Add stuff to link lists
LinkViewRef link_list_1 = source_row_1.get_linklist(1);
LinkViewRef link_list_2 = source_row_2.get_linklist(1);
link_list_1->add(15);
link_list_2->add(11);
link_list_2->add(15);
CHECK(!source_row_1.linklist_is_empty(1));
CHECK(!source_row_2.linklist_is_empty(1));
CHECK_EQUAL(1, source_row_1.get_link_count(1));
CHECK_EQUAL(2, source_row_2.get_link_count(1));
CHECK_EQUAL(1, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(2, target_table->get(15).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(1, target_table->get(11).get_backlink(*origin_table, 1, 0));
size_t back_link_1 = target_table->get(15).get_backlink(*origin_table, 1, 0);
size_t back_link_2 = target_table->get(15).get_backlink(*origin_table, 1, 1);
CHECK((back_link_1 == 0 && back_link_2 == 1) || (back_link_1 == 1 && back_link_2 == 0));
// Clear link lists
link_list_1->clear();
link_list_2->clear();
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
}
TEST(Table_RowAccessorDetach)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
Row row = table[0];
CHECK(row.is_attached());
row.detach();
CHECK(!row.is_attached());
row = table[0];
CHECK(row.is_attached());
}
TEST(Table_RowAccessor_DetachedRowExpr)
{
// Check that it is possible to create a detached RowExpr from scratch.
BasicRowExpr<Table> row;
CHECK_NOT(row.is_attached());
}
TEST(Table_RowAccessorCopyAndAssign)
{
Table table;
const Table& ctable = table;
table.add_column(type_Int, "");
table.add_empty_row(3);
table.set_int(0, 0, 750);
table.set_int(0, 1, 751);
table.set_int(0, 2, 752);
{
// Check copy construction of row accessor from row expression
Row row_1 = table[0]; // Copy construct `Row` from `RowExpr`
ConstRow crow_1 = table[1]; // Copy construct `ConstRow` from `RowExpr`
ConstRow crow_2 = ctable[2]; // Copy construct `ConstRow` from `ConstRowExpr`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
// Check copy construction of row accessor from other row accessor
Row drow_1;
ConstRow dcrow_1;
CHECK(!drow_1.is_attached());
CHECK(!dcrow_1.is_attached());
Row drow_2 = drow_1; // Copy construct `Row` from detached `Row`
ConstRow dcrow_2 = drow_1; // Copy construct `ConstRow` from detached `Row`
ConstRow dcrow_3 = dcrow_1; // Copy construct `ConstRow` from detached `ConstRow`
Row row_2 = row_1; // Copy construct `Row` from attached `Row`
ConstRow crow_3 = row_1; // Copy construct `ConstRow` from attached `Row`
ConstRow crow_4 = crow_1; // Copy construct `ConstRow` from attached `ConstRow`
CHECK(!drow_2.is_attached());
CHECK(!dcrow_2.is_attached());
CHECK(!dcrow_3.is_attached());
CHECK(row_2.is_attached());
CHECK(crow_3.is_attached());
CHECK(crow_4.is_attached());
CHECK(!drow_2.get_table());
CHECK(!dcrow_2.get_table());
CHECK(!dcrow_3.get_table());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(&table, crow_4.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(0, crow_3.get_index());
CHECK_EQUAL(1, crow_4.get_index());
}
table.verify();
// Check assignment of row expression to row accessor
{
Row row;
ConstRow crow_1, crow_2;
row = table[0]; // Assign `RowExpr` to detached `Row`
crow_1 = table[1]; // Assign `RowExpr` to detached `ConstRow`
crow_2 = ctable[2]; // Assign `ConstRowExpr` to detached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row = table[1]; // Assign `RowExpr` to attached `Row`
crow_1 = table[2]; // Assign `RowExpr` to attached `ConstRow`
crow_2 = ctable[0]; // Assign `ConstRowExpr` to attached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(1, row.get_index());
CHECK_EQUAL(2, crow_1.get_index());
CHECK_EQUAL(0, crow_2.get_index());
}
// Check assignment of row accessor to row accessor
{
Row drow, row_1;
ConstRow dcrow, crow_1, crow_2;
row_1 = row_1; // Assign detached `Row` to self
crow_1 = crow_1; // Assign detached `ConstRow` to self
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
row_1 = drow; // Assign detached `Row` to detached `Row`
crow_1 = drow; // Assign detached `Row` to detached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to detached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
Row row_2 = table[0];
Row row_3 = table[1];
ConstRow crow_3 = table[2];
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK(crow_3.is_attached());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, row_3.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(1, row_3.get_index());
CHECK_EQUAL(2, crow_3.get_index());
row_1 = row_2; // Assign attached `Row` to detached `Row`
crow_1 = row_3; // Assign attached `Row` to detached `ConstRow`
crow_2 = crow_3; // Assign attached `ConstRow` to detached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row_1 = row_1; // Assign attached `Row` to self
crow_1 = crow_1; // Assign attached `ConstRow` to self
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
Row row_4 = table[2];
Row row_5 = table[0];
ConstRow crow_4 = table[1];
row_1 = row_4; // Assign attached `Row` to attached `Row`
crow_1 = row_5; // Assign attached `Row` to attached `ConstRow`
crow_2 = crow_4; // Assign attached `ConstRow` to attached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(0, crow_1.get_index());
CHECK_EQUAL(1, crow_2.get_index());
row_1 = drow; // Assign detached `Row` to attached `Row`
crow_1 = drow; // Assign detached `Row` to attached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to attached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
}
}
TEST(Table_RowAccessorCopyConstructionBug)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
BasicRowExpr<Table> row_expr(table[0]);
BasicRow<Table> row_from_expr(row_expr);
BasicRow<Table> row_copy(row_from_expr);
table.remove(0);
CHECK_NOT(row_from_expr.is_attached());
CHECK_NOT(row_copy.is_attached());
}
TEST(Table_RowAccessorAssignMultipleTables)
{
Table tables[2];
for (int i = 0; i < 2; ++i) {
tables[i].add_column(type_Int, "");
tables[i].add_empty_row(3);
tables[i].set_int(0, 0, 750);
tables[i].set_int(0, 1, 751);
tables[i].set_int(0, 2, 752);
}
Row row_1 = tables[0][2];
Row row_2 = tables[1][2];
Row row_3 = tables[0][2];
row_1 = tables[1][2]; // Assign attached `Row` to a different table via RowExpr
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 2);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 1);
row_1 = row_3; // Assign attached `Row` to a different table via Row
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 0);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 0);
}
TEST(Table_RowAccessorRetain)
{
// Create a table with two rows
TableRef parent = Table::create();
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
ConstRow row_1 = (*parent)[0];
ConstRow row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that row insertion does not detach the row accessors, and that the
// row indexes is properly adjusted
parent->insert_empty_row(1); // Between
parent->add_empty_row(); // After
parent->insert_empty_row(0); // Before
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->insert_empty_row(1); // Immediately before row_1
parent->insert_empty_row(5); // Immediately after row_2
parent->insert_empty_row(3); // Immediately after row_1
parent->insert_empty_row(5); // Immediately before row_2
parent->verify();
CHECK_EQUAL(9, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(6, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of rows (other than row_1 and row_2) does not detach
// the row accessors, and that the row indexes is properly adjusted
parent->remove(3); // Immediately after row_1
parent->remove(1); // Immediately before row_1
parent->remove(3); // Immediately before row_2
parent->remove(4); // Immediately after row_2
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->remove(4); // After
parent->remove(0); // Before
parent->remove(1); // Between
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of first row detaches row_1
parent->remove(0);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(!row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(227, row_2.get_int(0));
// Restore first row and recover row_1
parent->insert_empty_row(0);
parent->set_int(0, 0, 27);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of second row detaches row_2
parent->remove(1);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(row_1.is_attached());
CHECK(!row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
// Restore second row and recover row_2
parent->add_empty_row();
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that descriptor modifications do not affect the row accessors (as
// long as we do not remove the last column)
parent->add_column(type_String, "x");
parent->insert_column(0, type_Float, "y");
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(1));
CHECK_EQUAL(227, row_2.get_int(1));
parent->remove_column(0);
parent->remove_column(1);
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of the last column detaches all row accessors
parent->remove_column(0);
parent->verify();
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
// Restore rows and recover row accessors
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that clearing of the table detaches all row accessors
parent->clear();
parent->verify();
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
}
TEST(Table_SubtableRowAccessorsRetain)
{
// Create a mixed and a regular subtable each with one row
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_column(type_Table, "b");
DescriptorRef subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(0, 0);
CHECK(mixed && mixed->is_attached());
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
TableRef regular = parent->get_subtable(1, 0);
CHECK(regular && regular->is_attached());
regular->add_empty_row();
regular->set_int(0, 0, 29);
CHECK(mixed->size() == 1);
CHECK(regular->size() == 1);
ConstRow row_m = (*mixed)[0];
ConstRow row_r = (*regular)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a mixed subtable are detached if the
// subtable is overridden
parent->set_mixed(0, 0, Mixed("foo"));
CHECK(!mixed->is_attached());
CHECK(regular->is_attached());
CHECK(!row_m.is_attached());
CHECK(row_r.is_attached());
// Restore mixed
parent->set_mixed(0, 0, Mixed::subtable_tag());
mixed = parent->get_subtable(0, 0);
CHECK(mixed);
CHECK(mixed->is_attached());
mixed->add_column(type_Int, "mixed_2");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
CHECK(regular->is_attached());
CHECK_EQUAL(1, mixed->size());
CHECK_EQUAL(1, regular->size());
row_m = (*mixed)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a regular subtable are detached if the
// subtable is overridden
parent->set_subtable(1, 0, nullptr); // Clear
CHECK(mixed->is_attached());
CHECK(regular->is_attached());
CHECK(row_m.is_attached());
CHECK(!row_r.is_attached());
}
TEST(Table_MoveLastOverRetain)
{
// Create three parent tables, each with with 5 rows, and each row
// containing one regular and one mixed subtable
TableRef parent_1, parent_2, parent_3;
for (int i = 0; i < 3; ++i) {
TableRef& parent = i == 0 ? parent_1 : i == 1 ? parent_2 : parent_3;
parent = Table::create();
parent->add_column(type_Table, "a");
parent->add_column(type_Mixed, "b");
DescriptorRef subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row(5);
for (int row_ndx = 0; row_ndx < 5; ++row_ndx) {
TableRef regular = parent->get_subtable(0, row_ndx);
regular->add_empty_row();
regular->set_int(0, 0, 10 + row_ndx);
parent->set_mixed(1, row_ndx, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(1, row_ndx);
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 20 + row_ndx);
}
}
// Use first table to check with accessors on row indexes 0, 1, and 4, but
// none at index 2 and 3.
{
TableRef parent = parent_1;
ConstRow row_0 = (*parent)[0];
ConstRow row_1 = (*parent)[1];
ConstRow row_4 = (*parent)[4];
TableRef regular_0 = parent->get_subtable(0, 0);
TableRef regular_1 = parent->get_subtable(0, 1);
TableRef regular_4 = parent->get_subtable(0, 4);
TableRef mixed_0 = parent->get_subtable(1, 0);
TableRef mixed_1 = parent->get_subtable(1, 1);
TableRef mixed_4 = parent->get_subtable(1, 4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(4, row_4.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0, 0));
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(14, regular_4->get_int(0, 0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_4 && mixed_4->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0, 0));
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(24, mixed_4->get_int(0, 0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(2, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(14, regular_4->get_int(0, 0));
CHECK_EQUAL(regular_1, parent->get_subtable(0, 1));
CHECK_EQUAL(regular_4, parent->get_subtable(0, 2));
CHECK(!mixed_0->is_attached());
CHECK(mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(24, mixed_4->get_int(0, 0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1, 1));
CHECK_EQUAL(mixed_4, parent->get_subtable(1, 2));
// Perform two more 'move last over' operations which brings the number
// of rows down from 3 to 1
parent->move_last_over(1); // Move row at index 2 to index 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(14, regular_4->get_int(0, 0));
CHECK_EQUAL(regular_4, parent->get_subtable(0, 0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(24, mixed_4->get_int(0, 0));
CHECK_EQUAL(mixed_4, parent->get_subtable(1, 0));
}
// Use second table to check with accessors on row indexes 0, 2, and 3, but
// none at index 1 and 4.
{
TableRef parent = parent_2;
ConstRow row_0 = (*parent)[0];
ConstRow row_2 = (*parent)[2];
ConstRow row_3 = (*parent)[3];
TableRef regular_0 = parent->get_subtable(0, 0);
TableRef regular_2 = parent->get_subtable(0, 2);
TableRef regular_3 = parent->get_subtable(0, 3);
TableRef mixed_0 = parent->get_subtable(1, 0);
TableRef mixed_2 = parent->get_subtable(1, 2);
TableRef mixed_3 = parent->get_subtable(1, 3);
CHECK(row_0.is_attached());
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(2, row_2.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0, 0));
CHECK_EQUAL(12, regular_2->get_int(0, 0));
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_2 && mixed_2->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0, 0));
CHECK_EQUAL(22, mixed_2->get_int(0, 0));
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(!mixed_3->is_attached());
}
// Use third table to check with accessors on row indexes 1 and 3, but none
// at index 0, 2, and 4.
{
TableRef parent = parent_3;
ConstRow row_1 = (*parent)[1];
ConstRow row_3 = (*parent)[3];
TableRef regular_1 = parent->get_subtable(0, 1);
TableRef regular_3 = parent->get_subtable(0, 3);
TableRef mixed_1 = parent->get_subtable(1, 1);
TableRef mixed_3 = parent->get_subtable(1, 3);
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(0, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_1, parent->get_subtable(0, 1));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1, 1));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(!mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_1.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_1->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(!mixed_3->is_attached());
}
}
TEST(Table_EnumStringInsertEmptyRow)
{
Table table;
table.add_column(type_String, "");
table.add_empty_row(128);
for (int i = 0; i < 128; ++i)
table.set_string(0, i, "foo");
DescriptorRef desc = table.get_descriptor();
CHECK_EQUAL(0, desc->get_num_unique_values(0));
table.optimize();
// Make sure we now have an enumerated strings column
CHECK_EQUAL(1, desc->get_num_unique_values(0));
table.add_empty_row();
CHECK_EQUAL("", table.get_string(0, 128));
}
TEST(Table_InsertColumnMaintainsBacklinkIndices)
{
Group g;
TableRef t0 = g.add_table("hrnetprsafd");
TableRef t1 = g.add_table("qrsfdrpnkd");
t1->add_column_link(type_Link, "bbb", *t0);
t1->add_column_link(type_Link, "ccc", *t0);
t1->insert_column(0, type_Int, "aaa");
t1->add_empty_row();
t0->add_column(type_Int, "foo");
t0->add_empty_row();
t1->remove_column(0);
t1->set_link(0, 0, 0);
t1->remove_column(0);
t1->set_link(0, 0, 0);
}
TEST(Table_MultipleLinkColumnsToSelf)
{
Group g;
TableRef t = g.add_table("A");
t->insert_column_link(0, type_Link, "e", *t);
t->insert_column_link(1, type_LinkList, "f", *t);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
_impl::TableFriend::move_column(*t->get_descriptor(), 0, 1);
g.verify();
t->get_linklist(0, 0)->add(0);
g.verify();
}
TEST(Table_MultipleLinkColumnsToOther)
{
Group g;
TableRef t = g.add_table("A");
TableRef t2 = g.add_table("B");
t->insert_column_link(0, type_Link, "e", *t2);
t->insert_column_link(1, type_LinkList, "f", *t);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
_impl::TableFriend::move_column(*t->get_descriptor(), 0, 1);
g.verify();
t->get_linklist(0, 0)->add(0);
g.verify();
}
TEST(Table_MultipleLinkColumnsMoveTables)
{
Group g;
TableRef t = g.add_table("A");
TableRef t2 = g.add_table("B");
t->insert_column_link(0, type_Link, "e", *t);
t->insert_column_link(1, type_LinkList, "f", *t);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
_impl::TableFriend::move_column(*t->get_descriptor(), 0, 1);
g.verify();
t->get_linklist(0, 0)->add(0);
g.verify();
g.move_table(0, 1);
g.verify();
g.move_table(1, 0);
g.verify();
}
TEST(Table_MultipleLinkColumnsMoveTablesCrossLinks)
{
Group g;
TableRef t = g.add_table("A");
TableRef t2 = g.add_table("B");
t->insert_column_link(0, type_Link, "e", *t2);
t->insert_column_link(1, type_LinkList, "f", *t);
t->insert_column_link(2, type_Link, "g", *t2);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
g.move_table(0, 1);
g.verify();
_impl::TableFriend::move_column(*t->get_descriptor(), 1, 2);
g.verify();
t->get_linklist(2, 0)->add(0);
g.verify();
g.move_table(1, 0);
g.verify();
_impl::TableFriend::move_column(*t->get_descriptor(), 1, 0);
g.verify();
}
TEST(Table_AddColumnWithThreeLevelBptree)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE * REALM_MAX_BPNODE_SIZE + 1);
table.add_column(type_Int, "");
table.verify();
}
TEST(Table_ClearWithTwoLevelBptree)
{
Table table;
table.add_column(type_Mixed, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE + 1);
table.clear();
table.verify();
}
TEST(Table_IndexStringDelete)
{
Table t;
t.add_column(type_String, "str");
t.add_search_index(0);
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
std::string out(util::to_string(i));
t.set_string(0, i, out);
}
t.clear();
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
std::string out(util::to_string(i));
t.set_string(0, i, out);
}
}
TEST(Table_Nulls)
{
// 'round' lets us run this entire test both with and without index and with/without optimize/enum
for (size_t round = 0; round < 5; round++) {
Table t;
TableView tv;
t.add_column(type_String, "str", true /*nullable*/);
if (round == 1)
t.add_search_index(0);
else if (round == 2)
t.optimize(true);
else if (round == 3) {
t.add_search_index(0);
t.optimize(true);
}
else if (round == 4) {
t.optimize(true);
t.add_search_index(0);
}
t.add_empty_row(3);
t.set_string(0, 0, "foo"); // short strings
t.set_string(0, 1, "");
t.set_string(0, 2, realm::null());
CHECK_EQUAL(1, t.count_string(0, "foo"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "foo"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "foo");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYY"); // medium strings (< 64)
CHECK_EQUAL(1, t.count_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYY");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
// long strings (>= 64)
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, t.count_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0,
t.find_first_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
}
{
Table t;
t.add_column(type_Int, "int", true); // nullable = true
t.add_column(type_Bool, "bool", true); // nullable = true
t.add_column(type_OldDateTime, "bool", true); // nullable = true
t.add_empty_row(2);
t.set_int(0, 0, 65);
t.set_bool(1, 0, false);
t.set_olddatetime(2, 0, OldDateTime(3));
CHECK_EQUAL(65, t.get_int(0, 0));
CHECK_EQUAL(false, t.get_bool(1, 0));
CHECK_EQUAL(OldDateTime(3), t.get_olddatetime(2, 0));
CHECK_EQUAL(65, t.maximum_int(0));
CHECK_EQUAL(65, t.minimum_int(0));
CHECK_EQUAL(OldDateTime(3), t.maximum_olddatetime(2));
CHECK_EQUAL(OldDateTime(3), t.minimum_olddatetime(2));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(!t.is_null(2, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK(t.is_null(2, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(1, t.find_first_null(2));
CHECK_EQUAL(not_found, t.find_first_int(0, -1));
CHECK_EQUAL(not_found, t.find_first_bool(1, true));
CHECK_EQUAL(not_found, t.find_first_olddatetime(2, OldDateTime(5)));
CHECK_EQUAL(0, t.find_first_int(0, 65));
CHECK_EQUAL(0, t.find_first_bool(1, false));
CHECK_EQUAL(0, t.find_first_olddatetime(2, OldDateTime(3)));
t.set_null(0, 0);
t.set_null(1, 0);
t.set_null(2, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
CHECK(t.is_null(2, 0));
}
{
Table t;
t.add_column(type_Float, "float", true); // nullable = true
t.add_column(type_Double, "double", true); // nullable = true
t.add_empty_row(2);
t.set_float(0, 0, 1.23f);
t.set_double(1, 0, 12.3);
CHECK_EQUAL(1.23f, t.get_float(0, 0));
CHECK_EQUAL(12.3, t.get_double(1, 0));
CHECK_EQUAL(1.23f, t.maximum_float(0));
CHECK_EQUAL(1.23f, t.minimum_float(0));
CHECK_EQUAL(12.3, t.maximum_double(1));
CHECK_EQUAL(12.3, t.minimum_double(1));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(not_found, t.find_first_float(0, 2.22f));
CHECK_EQUAL(not_found, t.find_first_double(1, 2.22));
CHECK_EQUAL(0, t.find_first_float(0, 1.23f));
CHECK_EQUAL(0, t.find_first_double(1, 12.3));
t.set_null(0, 0);
t.set_null(1, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
}
}
TEST(Table_InsertSubstring)
{
struct Fixture {
Table table;
Fixture()
{
table.add_column(type_String, "");
table.add_empty_row();
table.set_string(0, 0, "0123456789");
}
};
{
Fixture f;
f.table.insert_substring(0, 0, 0, "x");
CHECK_EQUAL("x0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.insert_substring(0, 0, 5, "x");
CHECK_EQUAL("01234x56789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.insert_substring(0, 0, 10, "x");
CHECK_EQUAL("0123456789x", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.insert_substring(0, 0, 5, "");
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.insert_substring(1, 0, 5, "x"), LogicError::column_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.insert_substring(0, 1, 5, "x"), LogicError::row_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.insert_substring(0, 0, 11, "x"), LogicError::string_position_out_of_range);
}
}
TEST(Table_RemoveSubstring)
{
struct Fixture {
Table table;
Fixture()
{
table.add_column(type_String, "");
table.add_empty_row();
table.set_string(0, 0, "0123456789");
}
};
{
Fixture f;
f.table.remove_substring(0, 0, 0, 1);
CHECK_EQUAL("123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 9, 1);
CHECK_EQUAL("012345678", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 0);
CHECK_EQUAL("", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 5);
CHECK_EQUAL("01234", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 10);
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 5, 1000);
CHECK_EQUAL("01234", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 10, 0);
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 10, 1);
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.remove_substring(1, 0, 5, 1), LogicError::column_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.remove_substring(0, 1, 5, 1), LogicError::row_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.remove_substring(0, 0, 11, 1), LogicError::string_position_out_of_range);
}
}
TEST(Table_SwapRowsThenMoveLastOverWithBacklinks)
{
// Attempts to trigger bug where LinkColumn::swap_rows() would only swap its backlinks but forgot
// to swap its own values
Group g;
TableRef t1 = g.add_table("t1");
TableRef t2 = g.add_table("t2");
t1->add_column(type_Int, "i");
t2->add_column_link(type_Link, "l", *t1);
t1->add_empty_row(2);
t2->add_empty_row(2);
t2->set_link(0, 0, 0);
t2->set_link(0, 1, 1);
t2->swap_rows(0, 1);
t2->verify();
t2->move_last_over(0);
t2->verify();
}
TEST(Table_RowAccessor_Null)
{
Table table;
size_t col_bool = table.add_column(type_Bool, "bool", true);
size_t col_int = table.add_column(type_Int, "int", true);
size_t col_string = table.add_column(type_String, "string", true);
size_t col_float = table.add_column(type_Float, "float", true);
size_t col_double = table.add_column(type_Double, "double", true);
size_t col_date = table.add_column(type_OldDateTime, "date", true);
size_t col_binary = table.add_column(type_Binary, "binary", true);
size_t col_timestamp = table.add_column(type_Timestamp, "timestamp", true);
{
table.add_empty_row();
Row row = table[0];
row.set_null(col_bool);
row.set_null(col_int);
row.set_string(col_string, realm::null());
row.set_null(col_float);
row.set_null(col_double);
row.set_null(col_date);
row.set_binary(col_binary, BinaryData());
row.set_null(col_timestamp);
}
{
table.add_empty_row();
Row row = table[1];
row.set_bool(col_bool, true);
row.set_int(col_int, 1);
row.set_string(col_string, "1");
row.set_float(col_float, 1.0);
row.set_double(col_double, 1.0);
row.set_olddatetime(col_date, OldDateTime(1));
row.set_binary(col_binary, BinaryData("a"));
row.set_timestamp(col_timestamp, Timestamp(1, 2));
}
{
Row row = table[0];
CHECK(row.is_null(col_bool));
CHECK(row.is_null(col_int));
CHECK(row.is_null(col_string));
CHECK(row.is_null(col_float));
CHECK(row.is_null(col_double));
CHECK(row.is_null(col_date));
CHECK(row.is_null(col_binary));
CHECK(row.is_null(col_timestamp));
}
{
Row row = table[1];
CHECK_EQUAL(true, row.get_bool(col_bool));
CHECK_EQUAL(1, row.get_int(col_int));
CHECK_EQUAL("1", row.get_string(col_string));
CHECK_EQUAL(1.0, row.get_float(col_float));
CHECK_EQUAL(1.0, row.get_double(col_double));
CHECK_EQUAL(OldDateTime(1), row.get_olddatetime(col_date));
CHECK_EQUAL(BinaryData("a"), row.get_binary(col_binary));
CHECK_EQUAL(Timestamp(1, 2), row.get_timestamp(col_timestamp));
}
}
// This triggers a severe bug in the Array::alloc() allocator in which its capacity-doubling
// scheme forgets to test of the doubling has overflowed the maximum allowed size of an
// array which is 2^24 - 1 bytes
TEST(Table_AllocatorCapacityBug)
{
std::unique_ptr<char[]> buf(new char[20000000]);
// First a simple trigger of `Assertion failed: value <= 0xFFFFFFL [26000016, 16777215]`
{
ref_type ref = BinaryColumn::create(Allocator::get_default(), 0, false);
BinaryColumn c(Allocator::get_default(), ref, true);
c.add(BinaryData(buf.get(), 13000000));
c.set(0, BinaryData(buf.get(), 14000000));
c.destroy();
}
// Now a small fuzzy test to catch other such bugs
{
Table t;
t.add_column(type_Binary, "", true);
for (size_t j = 0; j < 100; j++) {
size_t r = (j * 123456789 + 123456789) % 100;
if (r < 20) {
t.add_empty_row();
}
else if (t.size() > 0 && t.size() < 5) {
// Set only if there are no more than 4 rows, else it takes up too much space on devices (4 * 16 MB
// worst case now)
size_t row = (j * 123456789 + 123456789) % t.size();
size_t len = (j * 123456789 + 123456789) % 16000000;
BinaryData bd;
bd = BinaryData(buf.get(), len);
t.set_binary(0, row, bd);
}
else if (t.size() >= 4) {
t.clear();
}
}
}
}
// Exposes crash when setting a int, float or double that has its least significant bit set
TEST(Table_MixedCrashValues)
{
GROUP_TEST_PATH(path);
const char* encryption_key = nullptr;
Group group(path, encryption_key, Group::mode_ReadWrite);
TableRef table = group.add_table("t");
table->add_column(type_Mixed, "m");
table->add_empty_row(3);
table->set_mixed(0, 0, Mixed(int64_t(-1)));
table->set_mixed(0, 1, Mixed(2.0f));
table->set_mixed(0, 2, Mixed(2.0));
CHECK_EQUAL(table->get_mixed(0, 0).get_int(), int64_t(-1));
CHECK_EQUAL(table->get_mixed(0, 1).get_float(), 2.0f);
CHECK_EQUAL(table->get_mixed(0, 2).get_double(), 2.0);
group.verify();
}
TEST(Table_ChangeLinkTargets_Links)
{
Group g;
TableRef t0 = g.add_table("t0");
TableRef t1 = g.add_table("t1");
t0->add_column_link(type_Link, "link", *t1);
t1->add_column(type_Int, "int");
t0->add_empty_row(10);
t1->add_empty_row(10);
for (int i = 0; i < 10; ++i) {
t0->set_link(0, i, i);
t1->set_int(0, i, i);
}
Row replaced_row = t1->get(0);
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 1);
t1->change_link_targets(0, 9);
CHECK(replaced_row.is_attached());
CHECK_EQUAL(t0->get_link(0, 0), 9);
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 0);
}
TEST(Table_ChangeLinkTargets_LinkLists)
{
Group g;
TableRef t0 = g.add_table("t0");
TableRef t1 = g.add_table("t1");
t0->add_column_link(type_LinkList, "linklist", *t1);
t1->add_column(type_Int, "int");
t0->add_empty_row(10);
t1->add_empty_row(10);
for (int i = 0; i < 10; ++i) {
auto links = t0->get_linklist(0, i);
links->add(i);
links->add((i + 1) % 10);
t1->set_int(0, i, i);
}
Row replaced_row = t1->get(0);
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 2);
t1->change_link_targets(0, 9);
CHECK(replaced_row.is_attached());
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 0);
CHECK_EQUAL(t0->get_linklist(0, 0)->size(), 2);
CHECK_EQUAL(t0->get_linklist(0, 0)->get(0).get_index(), 9);
CHECK_EQUAL(t0->get_linklist(0, 0)->get(1).get_index(), 1);
CHECK_EQUAL(t0->get_linklist(0, 9)->size(), 2);
CHECK_EQUAL(t0->get_linklist(0, 9)->get(0).get_index(), 9);
CHECK_EQUAL(t0->get_linklist(0, 9)->get(1).get_index(), 9);
}
// Minimal test case causing an assertion error because
// backlink columns are storing stale values referencing
// their respective link column index. If a link column
// index changes, the backlink column accessors must also
// be updated.
TEST(Table_MinimalStaleLinkColumnIndex)
{
Group g;
TableRef t = g.add_table("table");
t->add_column(type_Int, "int1");
t->add_search_index(0);
t->add_empty_row(2);
t->set_int(0, 1, 4444);
TableRef t2 = g.add_table("table2");
t2->add_column(type_Int, "int_col");
t2->add_column_link(type_Link, "link", *t);
t2->remove_column(0);
t->set_int_unique(0, 0, 4444); // crashed here
CHECK_EQUAL(t->get_int(0, 0), 4444);
CHECK_EQUAL(t->size(), 1);
}
// This test case is a simplified version of a bug revealed by fuzz testing
// set_int_unique triggers backlinks to update if the element to insert is
// not unique. The expected behaviour is that the new row containing the
// unique int will be removed and the old row will remain; this ensures
// uniques without throwing errors. This test was crashing (assert failed)
// when inserting a unique duplicate because backlink indices hadn't been
// updated after a column had been removed from the table containing the link.
TEST(Table_FuzzTestRevealed_SetUniqueAssert)
{
Group g;
g.add_table("string_index_test_table");
g.get_table(0)->add_search_index(g.get_table(0)->add_column(DataType(0), "aa", true));
g.get_table(0)->add_search_index(g.get_table(0)->add_column(DataType(0), "bb", true));
g.get_table(0)->insert_column(0, DataType(0), "cc", true);
g.get_table(0)->add_search_index(0);
g.get_table(0)->insert_column_link(3, type_Link, "dd", *g.get_table(0));
g.get_table(0)->add_empty_row(225);
{
TableRef t = g.get_table(0);
t->remove_column(1);
}
{
TableRef t = g.get_table(0);
t->remove_column(0);
}
g.get_table(0)->add_empty_row(186);
g.get_table(0)->find_first_int(0, 0);
g.get_table(0)->set_int_unique(0, 255, 1);
g.get_table(0)->find_first_int(0, 0);
g.get_table(0)->set_null(0, 53);
g.get_table(0)->set_int_unique(0, 97, 'l');
g.get_table(0)->add_empty_row(85);
g.get_table(0)->set_int_unique(0, 100, 'l'); // duplicate
CHECK_EQUAL(g.get_table(0)->get_int(0, 97), 'l');
CHECK_EQUAL(g.get_table(0)->get_int(0, 100), 0);
}
TEST(Table_InsertUniqueDuplicate_LinkedColumns)
{
Group g;
TableRef t = g.add_table("table");
t->add_column(type_Int, "int1");
t->add_search_index(0);
t->add_empty_row(2);
t->set_int_unique(0, 0, 42);
t->set_int_unique(0, 1, 42);
CHECK_EQUAL(t->size(), 1);
CHECK_EQUAL(t->get_int(0, 0), 42);
t->insert_column(0, type_String, "string1");
t->add_search_index(0);
t->add_empty_row(1);
t->set_string_unique(0, 0, "fourty-two");
t->set_string_unique(0, 1, "fourty-two");
CHECK_EQUAL(t->size(), 1);
CHECK_EQUAL(t->get_string(0, 0), "fourty-two");
CHECK_EQUAL(t->get_int(1, 0), 42);
TableRef t2 = g.add_table("table2");
t2->add_column(type_Int, "int_col");
t2->add_column(type_String, "string_col");
t2->add_column_link(type_Link, "link", *t);
t2->add_search_index(0);
t2->add_search_index(1);
t2->add_empty_row(2);
t2->set_int_unique(0, 0, 43);
t2->set_string_unique(1, 0, "fourty-three");
t2->set_string_unique(1, 1, "FOURTY_THREE");
t2->set_link(2, 0, 0);
t2->set_int_unique(0, 1, 43); // deletes row 1, row 0 is winner
CHECK_EQUAL(t2->size(), 1);
CHECK_EQUAL(t2->get_int(0, 0), 43);
CHECK_EQUAL(t2->get_string(1, 0), "fourty-three");
CHECK_EQUAL(t2->get_link(2, 0), 0);
t2->remove_column(0);
t->insert_empty_row(0); // update t2 link through backlinks
t->set_int(1, 0, 333);
CHECK_EQUAL(t->get_int(1, 0), 333);
CHECK_EQUAL(t->get_int(1, 1), 42);
CHECK_EQUAL(t2->get_link(1, 0), 1); // bumped forward by insert at t(0), updated through backlinks
using df = _impl::DescriptorFriend;
DescriptorRef t2_descriptor = t2->get_descriptor();
df::move_column(*t2_descriptor, 0, 1);
CHECK_EQUAL(t2->get_link(0, 0), 1); // unchanged
t->insert_empty_row(0);
t->set_int(1, 0, 4444);
CHECK_EQUAL(t2->get_link(0, 0), 2); // bumped forward via backlinks
t2->remove_column(1);
CHECK_EQUAL(t2->get_link(0, 0), 2); // unchanged
t->insert_empty_row(0); // update through backlinks
t->set_int(1, 0, 55555);
CHECK_EQUAL(t2->get_link(0, 0), 3);
t->set_int_unique(1, 0, 4444); // duplicate, row 1 wins, move_last_over(0)
CHECK_EQUAL(t2->get_link(0, 0), 0); // changed by duplicate overwrite in linked table via backlinks
t2->insert_column(0, type_Int, "type_Int col");
CHECK_EQUAL(t2->get_link(1, 0), 0); // no change after insert col
t->insert_empty_row(0);
t->set_int(1, 0, 666666);
CHECK_EQUAL(t2->get_link(1, 0), 1); // bumped forward via backlinks
df::move_column(*t2_descriptor, 1, 0); // move backwards
CHECK_EQUAL(t2->get_link(0, 0), 1); // no change
t->insert_empty_row(0);
t->set_int(1, 0, 7777777);
CHECK_EQUAL(t2->get_link(0, 0), 2); // bumped forward via backlinks
t->remove(0);
CHECK_EQUAL(t2->get_link(0, 0), 1); // bumped back via backlinks
}
TEST(Table_DetachedAccessor)
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "i");
table->add_column(type_String, "s");
table->add_column(type_Binary, "b");
table->add_column_link(type_Link, "l", *table);
table->add_empty_row(2);
group.remove_table("table");
CHECK_LOGIC_ERROR(table->clear(), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->add_search_index(0), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->remove_search_index(0), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->change_link_targets(0, 1), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->swap_rows(0, 1), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_string(1, 0, ""), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_string_unique(1, 0, ""), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->insert_substring(1, 0, 0, "x"), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->remove_substring(1, 0, 0), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_binary(2, 0, BinaryData()), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_link(3, 0, 0), LogicError::detached_accessor);
}
// This test reproduces a user reported assertion failure. The problem was
// due to BacklinkColumn::m_origin_column_ndx not being updated when the
// linked table removed/inserted columns (this happened on a migration)
TEST(Table_StaleLinkIndexOnTableRemove)
{
SHARED_GROUP_TEST_PATH(path);
std::unique_ptr<Replication> hist(realm::make_in_realm_history(path));
SharedGroup sg_w(*hist, SharedGroupOptions(crypt_key()));
Group& group_w = const_cast<Group&>(sg_w.begin_read());
LangBindHelper::promote_to_write(sg_w);
TableRef t = group_w.add_table("table1");
t->add_column(type_Int, "int1");
t->add_empty_row(2);
TableRef t2 = group_w.add_table("table2");
t2->add_column(type_Int, "int_col");
t2->add_column_link(type_Link, "link", *t);
t2->add_empty_row();
t2->set_link(1, 0, 1);
t2->remove_column(0); // after this call LinkColumnBase::m_column_ndx was incorrect
t2->add_column(type_Int, "int_col2");
// The stale backlink index would still be "1" which is now an integer column in t2
// so the assertion in Spec::get_opposite_link_table() would fail when removing a link
t->remove(1);
CHECK_EQUAL(t->size(), 1);
CHECK_EQUAL(t2->get_link(0, 0), realm::npos); // no link
}
TEST(Table_ColumnsSupportStringIndex)
{
std::vector<DataType> all_types{type_Int, type_Bool, type_Float, type_Double, type_String,
type_Binary, type_OldDateTime, type_Timestamp, type_Table, type_Mixed};
std::vector<DataType> supports_index{type_Int, type_Bool, type_String, type_OldDateTime, type_Timestamp};
Group g; // type_Link must be part of a group
TableRef t = g.add_table("t1");
for (auto it = all_types.begin(); it != all_types.end(); ++it) {
t->add_column(*it, "");
ColumnBase& col = _impl::TableFriend::get_column(*t, 0);
bool does_support_index = col.supports_search_index();
auto found_pos = std::find(supports_index.begin(), supports_index.end(), *it);
CHECK_EQUAL(does_support_index, (found_pos != supports_index.end()));
CHECK_EQUAL(does_support_index, (col.create_search_index() != nullptr));
CHECK_EQUAL(does_support_index, col.has_search_index());
col.destroy_search_index();
CHECK(!col.has_search_index());
if (does_support_index) {
t->add_search_index(0);
}
else {
CHECK_LOGIC_ERROR(t->add_search_index(0), LogicError::illegal_combination);
}
CHECK_EQUAL(does_support_index, t->has_search_index(0));
t->remove_column(0);
}
// Check type_Link
t->add_column_link(type_Link, "", *t);
ColumnBase& link_col = _impl::TableFriend::get_column(*t, 0);
CHECK(!link_col.supports_search_index());
CHECK(link_col.create_search_index() == nullptr);
CHECK(!link_col.has_search_index());
CHECK_LOGIC_ERROR(t->add_search_index(0), LogicError::illegal_combination);
t->remove_column(0);
// Check type_LinkList
t->add_column_link(type_LinkList, "", *t);
ColumnBase& linklist_col = _impl::TableFriend::get_column(*t, 0);
CHECK(!linklist_col.supports_search_index());
CHECK(linklist_col.create_search_index() == nullptr);
CHECK(!linklist_col.has_search_index());
CHECK_LOGIC_ERROR(t->add_search_index(0), LogicError::illegal_combination);
t->remove_column(0);
// Check StringEnum
t->add_column(type_String, "");
bool force = true;
t->optimize(force);
ColumnBase& enum_col = _impl::TableFriend::get_column(*t, 0);
CHECK(enum_col.supports_search_index());
CHECK(enum_col.create_search_index() != nullptr);
CHECK(enum_col.has_search_index());
enum_col.destroy_search_index();
CHECK(!enum_col.has_search_index());
t->add_search_index(0);
CHECK(enum_col.has_search_index());
t->remove_column(0);
}
TEST(Table_addRowsToTableWithNoColumns)
{
Group g; // type_Link must be part of a group
TableRef t = g.add_table("t");
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
CHECK_LOGIC_ERROR(t->insert_empty_row(0), LogicError::table_has_no_columns);
CHECK_EQUAL(t->size(), 0);
t->add_column(type_String, "str_col");
t->add_empty_row(1);
CHECK_EQUAL(t->size(), 1);
t->add_search_index(0);
t->insert_empty_row(0);
CHECK_EQUAL(t->size(), 2);
t->remove_column(0);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
// Can add rows to a table with backlinks
TableRef u = g.add_table("u");
u->add_column_link(type_Link, "link from u to t", *t);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
t->add_empty_row(1);
CHECK_EQUAL(t->size(), 1);
u->remove_column(0);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
// Do the exact same as above but with LinkLists
u->add_column_link(type_LinkList, "link list from u to t", *t);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
t->add_empty_row(1);
CHECK_EQUAL(t->size(), 1);
u->remove_column(0);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
// Check that links are nulled when connected table is cleared
u->add_column_link(type_Link, "link from u to t", *t);
u->add_empty_row(1);
CHECK_EQUAL(u->size(), 1);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(u->set_link(0, 0, 0), LogicError::target_row_index_out_of_range);
CHECK(u->is_null_link(0, 0));
CHECK_EQUAL(t->size(), 0);
t->add_empty_row();
u->set_link(0, 0, 0);
CHECK_EQUAL(u->get_link(0, 0), 0);
CHECK(!u->is_null_link(0, 0));
CHECK_EQUAL(t->size(), 1);
t->add_column(type_Int, "int column");
CHECK_EQUAL(t->size(), 1);
t->remove_column(0);
CHECK_EQUAL(t->size(), 0);
CHECK_EQUAL(u->size(), 1);
CHECK(u->is_null_link(0, 0));
}
TEST(Table_getVersionCounterAfterRowAccessor)
{
Table t;
size_t col_bool = t.add_column(type_Bool, "bool", true);
size_t col_int = t.add_column(type_Int, "int", true);
size_t col_string = t.add_column(type_String, "string", true);
size_t col_float = t.add_column(type_Float, "float", true);
size_t col_double = t.add_column(type_Double, "double", true);
size_t col_date = t.add_column(type_OldDateTime, "date", true);
size_t col_binary = t.add_column(type_Binary, "binary", true);
size_t col_timestamp = t.add_column(type_Timestamp, "timestamp", true);
t.add_empty_row(1);
int_fast64_t ver = t.get_version_counter();
int_fast64_t newVer;
auto check_ver_bump = [&]() {
newVer = t.get_version_counter();
CHECK_GREATER(newVer, ver);
ver = newVer;
};
t.set_bool(col_bool, 0, true);
check_ver_bump();
t.set_int(col_int, 0, 42);
check_ver_bump();
t.set_string(col_string, 0, "foo");
check_ver_bump();
t.set_float(col_float, 0, 0.42f);
check_ver_bump();
t.set_double(col_double, 0, 0.42);
check_ver_bump();
t.set_olddatetime(col_date, 0, 1234);
check_ver_bump();
t.set_binary(col_binary, 0, BinaryData("binary", 7));
check_ver_bump();
t.set_timestamp(col_timestamp, 0, Timestamp(777, 888));
check_ver_bump();
t.set_null(0, 0);
check_ver_bump();
}
// This test a bug where get_size_from_type_and_ref() returned off-by-one on nullable integer columns.
// It seems to be only invoked from Table::get_size_from_ref() which is fast static method that lets
// you find the size of a Table without having to create an instance of it. This seems to be only done
// on subtables, so the bug has not been triggered in public.
TEST_TYPES(Table_ColumnSizeFromRef, std::true_type, std::false_type)
{
constexpr bool nullable_toggle = TEST_TYPE::value;
Group g;
TableRef t = g.add_table("table");
t->add_column(type_Int, "int", nullable_toggle);
t->add_column(type_Bool, "bool", nullable_toggle);
t->add_column(type_String, "string", nullable_toggle);
t->add_column(type_Binary, "binary", nullable_toggle);
t->add_column(type_Double, "double");
t->add_column(type_Float, "float");
t->add_column(type_Mixed, "mixed");
t->add_column(type_Timestamp, "timestamp");
t->add_column_link(type_Link, "link", *t);
t->add_column_link(type_LinkList, "LinkList", *t);
auto check_column_sizes = [this, &t](size_t num_rows) {
t->clear();
t->add_empty_row(num_rows);
CHECK_EQUAL(t->size(), num_rows);
using tf = _impl::TableFriend;
Spec& t_spec = tf::get_spec(*t);
size_t actual_num_cols = t_spec.get_column_count();
for (size_t col_ndx = 0; col_ndx < actual_num_cols; ++col_ndx) {
ColumnType col_type = t_spec.get_column_type(col_ndx);
ColumnBase& base = tf::get_column(*t, col_ndx);
ref_type col_ref = base.get_ref();
bool nullable = (t_spec.get_column_attr(col_ndx) & col_attr_Nullable) == col_attr_Nullable;
size_t col_size = ColumnBase::get_size_from_type_and_ref(col_type, col_ref, base.get_alloc(), nullable);
CHECK_EQUAL(col_size, num_rows);
}
};
// Test leafs
check_column_sizes(REALM_MAX_BPNODE_SIZE - 1);
// Test empty
check_column_sizes(0);
// Test internal nodes
check_column_sizes(REALM_MAX_BPNODE_SIZE + 1);
// Test on boundary for good measure
check_column_sizes(REALM_MAX_BPNODE_SIZE);
// Try with more levels in the tree
check_column_sizes(10 * REALM_MAX_BPNODE_SIZE);
}
#endif // TEST_TABLE
Don't illegally set unique, set unique must operate on a new (empty) row.
/*************************************************************************
*
* Copyright 2016 Realm Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**************************************************************************/
#include "testsettings.hpp"
#ifdef TEST_TABLE
#include <algorithm>
#include <limits>
#include <string>
#include <fstream>
#include <ostream>
#include <realm.hpp>
#include <realm/history.hpp>
#include <realm/lang_bind_helper.hpp>
#include <realm/util/buffer.hpp>
#include <realm/util/to_string.hpp>
#include "util/misc.hpp"
#include "test.hpp"
using namespace realm;
using namespace realm::util;
using namespace realm::test_util;
using unit_test::TestContext;
// Test independence and thread-safety
// -----------------------------------
//
// All tests must be thread safe and independent of each other. This
// is required because it allows for both shuffling of the execution
// order and for parallelized testing.
//
// In particular, avoid using std::rand() since it is not guaranteed
// to be thread safe. Instead use the API offered in
// `test/util/random.hpp`.
//
// All files created in tests must use the TEST_PATH macro (or one of
// its friends) to obtain a suitable file system path. See
// `test/util/test_path.hpp`.
//
//
// Debugging and the ONLY() macro
// ------------------------------
//
// A simple way of disabling all tests except one called `Foo`, is to
// replace TEST(Foo) with ONLY(Foo) and then recompile and rerun the
// test suite. Note that you can also use filtering by setting the
// environment varible `UNITTEST_FILTER`. See `README.md` for more on
// this.
//
// Another way to debug a particular test, is to copy that test into
// `experiments/testcase.cpp` and then run `sh build.sh
// check-testcase` (or one of its friends) from the command line.
namespace {
REALM_TABLE_2(TupleTableType, first, Int, second, String)
} // anonymous namespace
#ifdef JAVA_MANY_COLUMNS_CRASH
REALM_TABLE_3(SubtableType, year, Int, daysSinceLastVisit, Int, conceptId, String)
REALM_TABLE_7(MainTableType, patientId, String, gender, Int, ethnicity, Int, yearOfBirth, Int, yearOfDeath, Int,
zipCode, String, events, Subtable<SubtableType>)
TEST(Table_ManyColumnsCrash2)
{
// Trying to reproduce Java crash.
for (int a = 0; a < 10; a++) {
Group group;
MainTableType::Ref mainTable = group.add_table<MainTableType>("PatientTable");
TableRef dynPatientTable = group.add_table("PatientTable");
dynPatientTable->add_empty_row();
for (int counter = 0; counter < 20000; counter++) {
#if 0
// Add row to subtable through typed interface
SubtableType::Ref subtable = mainTable[0].events->get_table_ref();
REALM_ASSERT(subtable->is_attached());
subtable->add(0, 0, "");
REALM_ASSERT(subtable->is_attached());
#else
// Add row to subtable through dynamic interface. This mimics Java closest
TableRef subtable2 = dynPatientTable->get_subtable(6, 0);
REALM_ASSERT(subtable2->is_attached());
size_t subrow = subtable2->add_empty_row();
REALM_ASSERT(subtable2->is_attached());
#endif
if ((counter % 1000) == 0) {
// std::cerr << counter << "\n";
}
}
}
}
#endif // JAVA_MANY_COLUMNS_CRASH
TEST(Table_Null)
{
{
// Check that add_empty_row() adds NULL string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name", true); // nullable = true
table->add_empty_row();
CHECK(table->get_string(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty string as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
CHECK(!table->is_nullable(0));
table->add_empty_row();
CHECK(!table->get_string(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_string(0, 0, realm::null()), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds null integer as default
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "name", true /*nullable*/);
CHECK(table->is_nullable(0));
table->add_empty_row();
CHECK(table->is_null(0, 0));
}
{
// Check that add_empty_row() adds 0 integer as default.
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Int, "name");
CHECK(!table->is_nullable(0));
table->add_empty_row();
CHECK(!table->is_null(0, 0));
CHECK_EQUAL(0, table->get_int(0, 0));
// Check that inserting null in non-nullable column will throw
CHECK_LOGIC_ERROR(table->set_null(0, 0), LogicError::column_not_nullable);
}
{
// Check that add_empty_row() adds NULL binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name", true /*nullable*/);
CHECK(table->is_nullable(0));
table->add_empty_row();
CHECK(table->get_binary(0, 0).is_null());
}
{
// Check that add_empty_row() adds empty binary as default
Group group;
TableRef table = group.add_table("test");
table->add_column(type_Binary, "name");
CHECK(!table->is_nullable(0));
table->add_empty_row();
CHECK(!table->get_binary(0, 0).is_null());
// Test that inserting null in non-nullable column will throw
CHECK_THROW_ANY(table->set_binary(0, 0, BinaryData()));
}
{
// Check that link columns are nullable.
Group group;
TableRef target = group.add_table("target");
TableRef table = group.add_table("table");
target->add_column(type_Int, "int");
table->add_column_link(type_Link, "link", *target);
CHECK(table->is_nullable(0));
CHECK(!target->is_nullable(0));
}
{
// Check that linklist columns are not nullable.
Group group;
TableRef target = group.add_table("target");
TableRef table = group.add_table("table");
target->add_column(type_Int, "int");
table->add_column_link(type_LinkList, "link", *target);
CHECK(!table->is_nullable(0));
CHECK(!target->is_nullable(0));
}
}
TEST(Table_DeleteCrash)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "name");
table->add_column(type_Int, "age");
table->add_empty_row(3);
table->set_string(0, 0, "Alice");
table->set_int(1, 0, 27);
table->set_string(0, 1, "Bob");
table->set_int(1, 1, 50);
table->set_string(0, 2, "Peter");
table->set_int(1, 2, 44);
table->remove(0);
table->remove(1);
}
TEST(Table_OptimizeCrash)
{
// This will crash at the .add() method
TupleTableType ttt;
ttt.optimize();
ttt.column().second.add_search_index();
ttt.clear();
ttt.add(1, "AA");
}
TEST(Table_1)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Int, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_int(1, ndx, 10);
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(10, table.get_int(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_int(0, i, 2 * i);
table.set_int(1, i, 20 * i);
}
for (size_t i = ndx; i < 7; ++i) {
const int64_t v1 = 2 * i;
const int64_t v2 = 20 * i;
CHECK_EQUAL(v1, table.get_int(0, i));
CHECK_EQUAL(v2, table.get_int(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_ColumnNameTooLong)
{
Group group;
TableRef table = group.add_table("foo");
const size_t buf_size = 64;
std::unique_ptr<char[]> buf(new char[buf_size]);
CHECK_LOGIC_ERROR(table->add_column(type_Int, StringData(buf.get(), buf_size)), LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column(0, type_Int, StringData(buf.get(), buf_size)),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->add_column_link(type_Link, StringData(buf.get(), buf_size), *table),
LogicError::column_name_too_long);
CHECK_LOGIC_ERROR(table->insert_column_link(0, type_Link, StringData(buf.get(), buf_size), *table),
LogicError::column_name_too_long);
table->add_column(type_Int, StringData(buf.get(), buf_size - 1));
table->insert_column(0, type_Int, StringData(buf.get(), buf_size - 1));
table->add_column_link(type_Link, StringData(buf.get(), buf_size - 1), *table);
table->insert_column_link(0, type_Link, StringData(buf.get(), buf_size - 1), *table);
}
TEST(Table_StringOrBinaryTooBig)
{
Table table;
table.add_column(type_String, "s");
table.add_column(type_Binary, "b");
table.add_column(type_Mixed, "m1");
table.add_column(type_Mixed, "m2");
table.add_empty_row();
table.set_string(0, 0, "01234567");
size_t large_bin_size = 0xFFFFF1;
size_t large_str_size = 0xFFFFF0; // null-terminate reduces max size by 1
std::unique_ptr<char[]> large_buf(new char[large_bin_size]);
CHECK_LOGIC_ERROR(table.set_string(0, 0, StringData(large_buf.get(), large_str_size)),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size)),
LogicError::binary_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size))),
LogicError::string_too_big);
CHECK_LOGIC_ERROR(table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size))),
LogicError::binary_too_big);
table.set_string(0, 0, StringData(large_buf.get(), large_str_size - 1));
table.set_binary(1, 0, BinaryData(large_buf.get(), large_bin_size - 1));
table.set_mixed(2, 0, Mixed(StringData(large_buf.get(), large_str_size - 1)));
table.set_mixed(3, 0, Mixed(BinaryData(large_buf.get(), large_bin_size - 1)));
}
TEST(Table_SetBinaryLogicErrors)
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Binary, "a");
table->add_column(type_Int, "b");
table->add_empty_row();
BinaryData bd;
CHECK_LOGIC_ERROR(table->set_binary(2, 0, bd), LogicError::column_index_out_of_range);
CHECK_LOGIC_ERROR(table->set_binary(0, 1, bd), LogicError::row_index_out_of_range);
CHECK_LOGIC_ERROR(table->set_null(0, 0), LogicError::column_not_nullable);
// FIXME: Must also check that Logic::type_mismatch is thrown on column type mismatch, but Table::set_binary()
// does not properly check it yet.
group.remove_table("table");
CHECK_LOGIC_ERROR(table->set_binary(0, 0, bd), LogicError::detached_accessor);
// Logic error LogicError::binary_too_big checked in Table_StringOrBinaryTooBig
}
TEST(Table_Floats)
{
Table table;
table.add_column(type_Float, "first");
table.add_column(type_Double, "second");
CHECK_EQUAL(type_Float, table.get_column_type(0));
CHECK_EQUAL(type_Double, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
// Test adding a single empty row
// and filling it with values
size_t ndx = table.add_empty_row();
table.set_float(0, ndx, float(1.12));
table.set_double(1, ndx, double(102.13));
CHECK_EQUAL(float(1.12), table.get_float(0, ndx));
CHECK_EQUAL(double(102.13), table.get_double(1, ndx));
// Test adding multiple rows
ndx = table.add_empty_row(7);
for (size_t i = ndx; i < 7; ++i) {
table.set_float(0, i, float(1.12) + 100 * i);
table.set_double(1, i, double(102.13) * 200 * i);
}
for (size_t i = ndx; i < 7; ++i) {
const float v1 = float(1.12) + 100 * i;
const double v2 = double(102.13) * 200 * i;
CHECK_EQUAL(v1, table.get_float(0, i));
CHECK_EQUAL(v2, table.get_double(1, i));
}
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun };
REALM_TABLE_4(TestTable, first, Int, second, Int, third, Bool, fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_2)
{
TestTable table;
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL(0, r.first);
CHECK_EQUAL(10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL(Wed, r.fourth);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_3)
{
TestTable table;
for (size_t i = 0; i < 100; ++i) {
table.add(0, 10, true, Wed);
}
// Test column searching
CHECK_EQUAL(size_t(0), table.column().first.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().first.find_first(1));
CHECK_EQUAL(size_t(0), table.column().second.find_first(10));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(100));
CHECK_EQUAL(size_t(0), table.column().third.find_first(true));
CHECK_EQUAL(size_t(-1), table.column().third.find_first(false));
CHECK_EQUAL(size_t(0), table.column().fourth.find_first(Wed));
CHECK_EQUAL(size_t(-1), table.column().fourth.find_first(Mon));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableEnum, first, Enum<Days>, second, String)
} // anonymous namespace
TEST(Table_4)
{
TestTableEnum table;
table.add(Mon, "Hello");
table.add(Mon, "HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello");
const TestTableEnum::Cursor r = table.back(); // last item
CHECK_EQUAL(Mon, r.first);
CHECK_EQUAL("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello", r.second);
// Test string column searching
CHECK_EQUAL(size_t(1), table.column().second.find_first(
"HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello"));
CHECK_EQUAL(size_t(-1), table.column().second.find_first("Foo"));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_2(TestTableFloats, first, Float, second, Double)
} // anonymous namespace
TEST(Table_Float2)
{
TestTableFloats table;
table.add(1.1f, 2.2);
table.add(1.1f, 2.2);
const TestTableFloats::Cursor r = table.back(); // last item
CHECK_EQUAL(1.1f, r.first);
CHECK_EQUAL(2.2, r.second);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Delete)
{
TestTable table;
for (size_t i = 0; i < 10; ++i) {
table.add(0, i, true, Wed);
}
table.remove(0);
table.remove(4);
table.remove(7);
CHECK_EQUAL(1, table[0].second);
CHECK_EQUAL(2, table[1].second);
CHECK_EQUAL(3, table[2].second);
CHECK_EQUAL(4, table[3].second);
CHECK_EQUAL(6, table[4].second);
CHECK_EQUAL(7, table[5].second);
CHECK_EQUAL(8, table[6].second);
#ifdef REALM_DEBUG
table.verify();
#endif
// Delete all items one at a time
for (size_t i = 0; i < 7; ++i) {
table.remove(0);
}
CHECK(table.is_empty());
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_GetName)
{
// Freestanding tables have no names
{
Table table;
CHECK_EQUAL("", table.get_name());
}
// ... regardless of how they are created
{
TableRef table = Table::create();
CHECK_EQUAL("", table->get_name());
}
// Direct members of groups do have names
{
Group group;
TableRef table = group.add_table("table");
CHECK_EQUAL("table", table->get_name());
}
{
Group group;
TableRef foo = group.add_table("foo");
TableRef bar = group.add_table("bar");
CHECK_EQUAL("foo", foo->get_name());
CHECK_EQUAL("bar", bar->get_name());
}
// Subtables should never have names
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "sub", &subdesc);
table.add_empty_row();
TableRef subtab = table.get_subtable(0, 0);
CHECK_EQUAL("", table.get_name());
CHECK_EQUAL("", subtab->get_name());
}
// ... not even when the parent is a member of a group
{
Group group;
TableRef table = group.add_table("table");
DescriptorRef subdesc;
table->add_column(type_Table, "sub", &subdesc);
table->add_empty_row();
TableRef subtab = table->get_subtable(0, 0);
CHECK_EQUAL("table", table->get_name());
CHECK_EQUAL("", subtab->get_name());
}
}
namespace {
void setup_multi_table(Table& table, size_t rows, size_t sub_rows, bool fixed_subtab_sizes = false)
{
// Create table with all column types
{
DescriptorRef sub1;
table.add_column(type_Int, "int"); // 0
table.add_column(type_Bool, "bool"); // 1
table.add_column(type_OldDateTime, "date"); // 2
table.add_column(type_Float, "float"); // 3
table.add_column(type_Double, "double"); // 4
table.add_column(type_String, "string"); // 5
table.add_column(type_String, "string_long"); // 6
table.add_column(type_String, "string_big_blobs"); // 7
table.add_column(type_String, "string_enum"); // 8 - becomes StringEnumColumn
table.add_column(type_Binary, "binary"); // 9
table.add_column(type_Table, "tables", &sub1); // 10
table.add_column(type_Mixed, "mixed"); // 11
table.add_column(type_Int, "int_null", true); // 12, nullable = true
sub1->add_column(type_Int, "sub_first");
sub1->add_column(type_String, "sub_second");
}
table.add_empty_row(rows);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
table.set_int(0, i, int64_t(i * sign));
if (i % 4 == 0) {
table.set_null(12, i);
}
else {
table.set_int(12, i, int64_t(i * sign));
}
}
for (size_t i = 0; i < rows; ++i)
table.set_bool(1, i, (i % 2 ? true : false));
for (size_t i = 0; i < rows; ++i)
table.set_olddatetime(2, i, 12345);
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
table.set_float(3, i, 123.456f * sign);
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
table.set_double(4, i, 9876.54321 * sign);
}
std::vector<std::string> strings;
for (size_t i = 0; i < rows; ++i) {
std::stringstream out;
out << "string" << i;
strings.push_back(out.str());
}
for (size_t i = 0; i < rows; ++i)
table.set_string(5, i, strings[i]);
for (size_t i = 0; i < rows; ++i) {
std::string str_i(strings[i] + " very long string.........");
table.set_string(6, i, str_i);
}
for (size_t i = 0; i < rows; ++i) {
switch (i % 2) {
case 0: {
std::string s = strings[i];
s += " very long string.........";
for (int j = 0; j != 4; ++j)
s += " big blobs big blobs big blobs"; // +30
table.set_string(7, i, s);
break;
}
case 1:
table.set_string(7, i, "");
break;
}
}
for (size_t i = 0; i < rows; ++i) {
switch (i % 3) {
case 0:
table.set_string(8, i, "enum1");
break;
case 1:
table.set_string(8, i, "enum2");
break;
case 2:
table.set_string(8, i, "enum3");
break;
}
}
for (size_t i = 0; i < rows; ++i)
table.set_binary(9, i, BinaryData("binary", 7));
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
size_t n = sub_rows;
if (!fixed_subtab_sizes)
n += i;
for (size_t j = 0; j != n; ++j) {
TableRef subtable = table.get_subtable(10, i);
int64_t val = -123 + i * j * 1234 * sign;
subtable->insert_empty_row(j);
subtable->set_int(0, j, val);
subtable->set_string(1, j, "sub");
}
}
for (size_t i = 0; i < rows; ++i) {
int64_t sign = (i % 2 == 0) ? 1 : -1;
switch (i % 8) {
case 0:
table.set_mixed(11, i, false);
break;
case 1:
table.set_mixed(11, i, int64_t(i * i * sign));
break;
case 2:
table.set_mixed(11, i, "string");
break;
case 3:
table.set_mixed(11, i, OldDateTime(123456789));
break;
case 4:
table.set_mixed(11, i, BinaryData("binary", 7));
break;
case 5: {
// Add subtable to mixed column
// We can first set schema and contents when the entire
// row has been inserted
table.set_mixed(11, i, Mixed::subtable_tag());
TableRef subtable = table.get_subtable(11, i);
subtable->add_column(type_Int, "first");
subtable->add_column(type_String, "second");
for (size_t j = 0; j != 2; ++j) {
subtable->insert_empty_row(j);
subtable->set_int(0, j, i * i * j * sign);
subtable->set_string(1, j, "mixed sub");
}
break;
}
case 6:
table.set_mixed(11, i, float(123.1 * i * sign));
break;
case 7:
table.set_mixed(11, i, double(987.65 * i * sign));
break;
}
}
// We also want a StringEnumColumn
table.optimize();
}
} // anonymous namespace
TEST(Table_LowLevelCopy)
{
Table table;
setup_multi_table(table, 15, 2);
#ifdef REALM_DEBUG
table.verify();
#endif
Table table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TableRef table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_HighLevelCopy)
{
TestTable table;
table.add(10, 120, false, Mon);
table.add(12, 100, true, Tue);
#ifdef REALM_DEBUG
table.verify();
#endif
TestTable table2 = table;
#ifdef REALM_DEBUG
table2.verify();
#endif
CHECK(table2 == table);
TestTable::Ref table3 = table.copy();
#ifdef REALM_DEBUG
table3->verify();
#endif
CHECK(*table3 == table);
}
TEST(Table_DeleteAllTypes)
{
Table table;
setup_multi_table(table, 15, 2);
// Test Deletes
table.remove(14);
table.remove(0);
table.remove(5);
CHECK_EQUAL(12, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
// Test Clear
table.clear();
CHECK_EQUAL(0, table.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
// Triggers a bug that would make Realm crash if you run optimize() followed by add_search_index()
TEST(Table_Optimize_SetIndex_Crash)
{
Table table;
table.add_column(type_String, "first");
table.add_empty_row(3);
table.set_string(0, 0, "string0");
table.set_string(0, 1, "string1");
table.set_string(0, 2, "string1");
table.optimize();
CHECK_NOT_EQUAL(0, table.get_descriptor()->get_num_unique_values(0));
table.set_string(0, 2, "string2");
table.add_search_index(0);
table.move_last_over(1);
table.move_last_over(1);
}
TEST(Table_MoveAllTypes)
{
Random random(random_int<unsigned long>()); // Seed from slow global generator
Table table;
setup_multi_table(table, 15, 2);
table.add_search_index(6);
while (!table.is_empty()) {
size_t size = table.size();
size_t target_row_ndx = random.draw_int_mod(size);
table.move_last_over(target_row_ndx);
table.verify();
}
}
TEST(Table_DegenerateSubtableSearchAndAggregate)
{
Table parent;
// Add all column types
{
DescriptorRef sub_1, sub_2;
parent.add_column(type_Table, "child", &sub_1);
sub_1->add_column(type_Int, "int"); // 0
sub_1->add_column(type_Bool, "bool"); // 1
sub_1->add_column(type_Float, "float"); // 2
sub_1->add_column(type_Double, "double"); // 3
sub_1->add_column(type_OldDateTime, "date"); // 4
sub_1->add_column(type_String, "string"); // 5
sub_1->add_column(type_Binary, "binary"); // 6
sub_1->add_column(type_Table, "table", &sub_2); // 7
sub_1->add_column(type_Mixed, "mixed"); // 8
sub_1->add_column(type_Int, "int_null", nullptr, true); // 9, nullable = true
sub_2->add_column(type_Int, "i");
}
parent.add_empty_row(); // Create a degenerate subtable
ConstTableRef degen_child = parent.get_subtable(0, 0); // NOTE: Constness is essential here!!!
CHECK_EQUAL(0, degen_child->size());
CHECK_EQUAL(10, degen_child->get_column_count());
// Searching:
// CHECK_EQUAL(0, degen_child->distinct(0).size()); // needs index but you cannot set index on ConstTableRef
CHECK_EQUAL(0, degen_child->get_sorted_view(0).size());
CHECK_EQUAL(not_found, degen_child->find_first_int(0, 0));
CHECK_EQUAL(not_found, degen_child->find_first_bool(1, false));
CHECK_EQUAL(not_found, degen_child->find_first_float(2, 0));
CHECK_EQUAL(not_found, degen_child->find_first_double(3, 0));
CHECK_EQUAL(not_found, degen_child->find_first_olddatetime(4, OldDateTime()));
CHECK_EQUAL(not_found, degen_child->find_first_string(5, StringData("")));
// CHECK_EQUAL(not_found, degen_child->find_first_binary(6, BinaryData())); // Exists but not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->find_first_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->find_all_int(0, 0).size());
CHECK_EQUAL(0, degen_child->find_all_bool(1, false).size());
CHECK_EQUAL(0, degen_child->find_all_float(2, 0).size());
CHECK_EQUAL(0, degen_child->find_all_double(3, 0).size());
CHECK_EQUAL(0, degen_child->find_all_olddatetime(4, OldDateTime()).size());
CHECK_EQUAL(0, degen_child->find_all_string(5, StringData("")).size());
// CHECK_EQUAL(0, degen_child->find_all_binary(6, BinaryData()).size()); // Exists but not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_subtable(7, subtab).size()); // Not yet implemented
// CHECK_EQUAL(0, degen_child->find_all_mixed(8, Mixed()).size()); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->lower_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->lower_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->lower_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->lower_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->lower_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->lower_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->lower_bound_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_int(0, 0));
CHECK_EQUAL(0, degen_child->upper_bound_bool(1, false));
CHECK_EQUAL(0, degen_child->upper_bound_float(2, 0));
CHECK_EQUAL(0, degen_child->upper_bound_double(3, 0));
// CHECK_EQUAL(0, degen_child->upper_bound_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->upper_bound_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->upper_bound_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->upper_bound_mixed(8, Mixed())); // Not yet implemented
// Aggregates:
CHECK_EQUAL(0, degen_child->count_int(0, 0));
// CHECK_EQUAL(0, degen_child->count_bool(1, false)); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_float(2, 0));
CHECK_EQUAL(0, degen_child->count_double(3, 0));
// CHECK_EQUAL(0, degen_child->count_date(4, Date())); // Not yet implemented
CHECK_EQUAL(0, degen_child->count_string(5, StringData("")));
// CHECK_EQUAL(0, degen_child->count_binary(6, BinaryData())); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_subtable(7, subtab)); // Not yet implemented
// CHECK_EQUAL(0, degen_child->count_mixed(8, Mixed())); // Not yet implemented
CHECK_EQUAL(0, degen_child->minimum_int(0));
CHECK_EQUAL(0, degen_child->minimum_float(2));
CHECK_EQUAL(0, degen_child->minimum_double(3));
CHECK_EQUAL(0, degen_child->minimum_olddatetime(4));
CHECK_EQUAL(0, degen_child->maximum_int(0));
CHECK_EQUAL(0, degen_child->maximum_float(2));
CHECK_EQUAL(0, degen_child->maximum_double(3));
CHECK_EQUAL(0, degen_child->maximum_olddatetime(4));
CHECK_EQUAL(0, degen_child->sum_int(0));
CHECK_EQUAL(0, degen_child->sum_float(2));
CHECK_EQUAL(0, degen_child->sum_double(3));
CHECK_EQUAL(0, degen_child->average_int(0));
CHECK_EQUAL(0, degen_child->average_float(2));
CHECK_EQUAL(0, degen_child->average_double(3));
// Queries:
CHECK_EQUAL(not_found, degen_child->where().equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(1, false).find());
CHECK_EQUAL(not_found, degen_child->where().equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().equal_olddatetime(4, OldDateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().equal(8, Mixed()).find()); // Not yet implemented
CHECK_EQUAL(not_found, degen_child->where().not_equal(0, int64_t()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(2, float()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(3, double()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal_olddatetime(4, OldDateTime()).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(5, StringData("")).find());
CHECK_EQUAL(not_found, degen_child->where().not_equal(6, BinaryData()).find());
// CHECK_EQUAL(not_found, degen_child->where().not_equal(7, subtab).find()); // Not yet implemented
// CHECK_EQUAL(not_found, degen_child->where().not_equal(8, Mixed()).find()); // Not yet implemented
TableView v = degen_child->where().equal(0, int64_t()).find_all();
CHECK_EQUAL(0, v.size());
v = degen_child->where().equal(5, "hello").find_all();
CHECK_EQUAL(0, v.size());
size_t r = degen_child->where().equal(5, "hello").count();
CHECK_EQUAL(0, r);
r = degen_child->where().equal(5, "hello").remove();
CHECK_EQUAL(0, r);
size_t res;
degen_child->where().equal(5, "hello").average_int(0, &res);
CHECK_EQUAL(0, res);
}
TEST(Table_Range)
{
Table table;
table.add_column(type_Int, "int");
table.add_empty_row(100);
for (size_t i = 0; i < 100; ++i)
table.set_int(0, i, i);
TableView tv = table.get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i < tv.size(); ++i)
CHECK_EQUAL(int64_t(i + 10), tv.get_int(0, i));
}
TEST(Table_RangeConst)
{
Group group;
{
TableRef table = group.add_table("test");
table->add_column(type_Int, "int");
table->add_empty_row(100);
for (int i = 0; i < 100; ++i)
table->set_int(0, i, i);
}
ConstTableRef ctable = group.get_table("test");
ConstTableView tv = ctable->get_range_view(10, 20);
CHECK_EQUAL(10, tv.size());
for (size_t i = 0; i < tv.size(); ++i)
CHECK_EQUAL(int64_t(i + 10), tv.get_int(0, i));
}
// enable to generate testfiles for to_string below
#define GENERATE 0
TEST(Table_ToString)
{
Table table;
setup_multi_table(table, 15, 6);
std::stringstream ss;
table.to_string(ss);
const std::string result = ss.str();
std::string file_name = get_test_resource_path();
file_name += "expect_string.txt";
#if GENERATE // enable to generate testfile - check it manually
std::ofstream test_file(file_name.c_str(), std::ios::out);
test_file << result;
std::cerr << "to_string() test:\n" << result << std::endl;
#else
std::ifstream test_file(file_name.c_str(), std::ios::in);
CHECK(!test_file.fail());
std::string expected;
expected.assign(std::istreambuf_iterator<char>(test_file), std::istreambuf_iterator<char>());
bool test_ok = test_util::equal_without_cr(result, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
TEST_PATH(path);
File out(path, File::mode_Write);
out.write(result);
std::cerr << "\n error result in '" << std::string(path) << "'\n";
}
#endif
}
/* DISABLED BECAUSE IT FAILS - A PULL REQUEST WILL BE MADE WHERE IT IS REENABLED!
TEST(Table_RowToString)
{
// Create table with all column types
Table table;
setup_multi_table(table, 2, 2);
std::stringstream ss;
table.row_to_string(1, ss);
const std::string row_str = ss.str();
#if 0
std::ofstream test_file("row_to_string.txt", ios::out);
test_file << row_str;
#endif
std::string expected = " int bool date float double string
string_long string_enum binary mixed tables\n"
"1: -1 true 1970-01-01 03:25:45 -1.234560e+002 -9.876543e+003 string1 string1 very long
st... enum2 7 bytes -1 [3]\n";
bool test_ok = test_util::equal_without_cr(row_str, expected);
CHECK_EQUAL(true, test_ok);
if (!test_ok) {
std::cerr << "row_to_string() failed\n"
<< "Expected: " << expected << "\n"
<< "Got : " << row_str << std::endl;
}
}
TEST(Table_FindInt)
{
TestTable table;
for (int i = 1000; i >= 0; --i) {
table.add(0, i, true, Wed);
}
CHECK_EQUAL(size_t(0), table.column().second.find_first(1000));
CHECK_EQUAL(size_t(1000), table.column().second.find_first(0));
CHECK_EQUAL(size_t(-1), table.column().second.find_first(1001));
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
/*
TEST(Table_6)
{
TestTableEnum table;
RLM_QUERY(TestQuery, TestTableEnum) {
// first.between(Mon, Thu);
second == "Hello" || (second == "Hey" && first == Mon);
}};
RLM_QUERY_OPT(TestQuery2, TestTableEnum) (Days a, Days b, const char* str) {
static_cast<void>(b);
static_cast<void>(a);
//first.between(a, b);
second == str || second.MatchRegEx(".*");
}};
//TestTableEnum result = table.find_all(TestQuery2(Mon, Tue, "Hello")).sort().Limit(10);
//size_t result2 = table.Range(10, 200).find_first(TestQuery());
//CHECK_EQUAL((size_t)-1, result2);
#ifdef REALM_DEBUG
table.verify();
#endif
}
*/
TEST(Table_FindAllInt)
{
TestTable table;
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
// Search for a value that does not exits
const TestTable::View v0 = table.column().second.find_all(5);
CHECK_EQUAL(0, v0.size());
// Search for a value with several matches
const TestTable::View v = table.column().second.find_all(20);
CHECK_EQUAL(5, v.size());
CHECK_EQUAL(1, v.get_source_ndx(0));
CHECK_EQUAL(3, v.get_source_ndx(1));
CHECK_EQUAL(5, v.get_source_ndx(2));
CHECK_EQUAL(7, v.get_source_ndx(3));
CHECK_EQUAL(9, v.get_source_ndx(4));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_SortedInt)
{
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, true, Wed); // 1: 7
table.add(0, 0, true, Wed); // 2: 0
table.add(0, 40, true, Wed); // 3: 8
table.add(0, 15, true, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Search for a value that does not exits
TestTable::View v = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v.size());
CHECK_EQUAL(2, v.get_source_ndx(0));
CHECK_EQUAL(9, v.get_source_ndx(1));
CHECK_EQUAL(7, v.get_source_ndx(2));
CHECK_EQUAL(6, v.get_source_ndx(3));
CHECK_EQUAL(0, v.get_source_ndx(4));
CHECK_EQUAL(5, v.get_source_ndx(5));
CHECK_EQUAL(4, v.get_source_ndx(6));
CHECK_EQUAL(1, v.get_source_ndx(7));
CHECK_EQUAL(3, v.get_source_ndx(8));
CHECK_EQUAL(8, v.get_source_ndx(9));
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Sorted_Query_where)
{
// Using where(tv) instead of tableview(tv)
TestTable table;
table.add(0, 10, true, Wed); // 0: 4
table.add(0, 20, false, Wed); // 1: 7
table.add(0, 0, false, Wed); // 2: 0
table.add(0, 40, false, Wed); // 3: 8
table.add(0, 15, false, Wed); // 4: 6
table.add(0, 11, true, Wed); // 5: 5
table.add(0, 6, true, Wed); // 6: 3
table.add(0, 4, true, Wed); // 7: 2
table.add(0, 99, true, Wed); // 8: 9
table.add(0, 2, true, Wed); // 9: 1
// Count booleans
size_t count_original = table.where().third.equal(false).count();
CHECK_EQUAL(4, count_original);
// Get a view containing the complete table
TestTable::View v = table.column().first.find_all(0);
CHECK_EQUAL(table.size(), v.size());
// Count booleans
size_t count_view = table.where(&v).third.equal(false).count();
CHECK_EQUAL(4, count_view);
TestTable::View v_sorted = table.column().second.get_sorted_view();
CHECK_EQUAL(table.size(), v_sorted.size());
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Multi_Sort)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "second");
table.add_empty_row(5);
// 1, 10
table.set_int(0, 0, 1);
table.set_int(1, 0, 10);
// 2, 10
table.set_int(0, 1, 2);
table.set_int(1, 1, 10);
// 0, 10
table.set_int(0, 2, 0);
table.set_int(1, 2, 10);
// 2, 14
table.set_int(0, 3, 2);
table.set_int(1, 3, 14);
// 1, 14
table.set_int(0, 4, 1);
table.set_int(1, 4, 14);
std::vector<std::vector<size_t>> col_ndx1 = {{0}, {1}};
std::vector<bool> asc = {true, true};
// (0, 10); (1, 10); (1, 14); (2, 10); (2; 14)
TableView v_sorted1 = table.get_sorted_view(SortDescriptor{table, col_ndx1, asc});
CHECK_EQUAL(table.size(), v_sorted1.size());
CHECK_EQUAL(2, v_sorted1.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted1.get_source_ndx(1));
CHECK_EQUAL(4, v_sorted1.get_source_ndx(2));
CHECK_EQUAL(1, v_sorted1.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted1.get_source_ndx(4));
std::vector<std::vector<size_t>> col_ndx2 = {{1}, {0}};
// (0, 10); (1, 10); (2, 10); (1, 14); (2, 14)
TableView v_sorted2 = table.get_sorted_view(SortDescriptor{table, col_ndx2, asc});
CHECK_EQUAL(table.size(), v_sorted2.size());
CHECK_EQUAL(2, v_sorted2.get_source_ndx(0));
CHECK_EQUAL(0, v_sorted2.get_source_ndx(1));
CHECK_EQUAL(1, v_sorted2.get_source_ndx(2));
CHECK_EQUAL(4, v_sorted2.get_source_ndx(3));
CHECK_EQUAL(3, v_sorted2.get_source_ndx(4));
}
TEST(Table_IndexString)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); // duplicate
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
const size_t r1 = table.column().second.find_first("jimmi");
CHECK_EQUAL(not_found, r1);
const size_t r2 = table.column().second.find_first("jeff");
const size_t r3 = table.column().second.find_first("jim");
const size_t r4 = table.column().second.find_first("jimbo");
const size_t r5 = table.column().second.find_first("johnny");
CHECK_EQUAL(0, r2);
CHECK_EQUAL(1, r3);
CHECK_EQUAL(5, r4);
CHECK_EQUAL(6, r5);
const size_t c1 = table.column().second.count("jennifer");
CHECK_EQUAL(2, c1);
}
TEST(Table_IndexStringTwice)
{
TestTableEnum table;
table.add(Mon, "jeff");
table.add(Tue, "jim");
table.add(Wed, "jennifer");
table.add(Thu, "john");
table.add(Fri, "jimmy");
table.add(Sat, "jimbo");
table.add(Sun, "johnny");
table.add(Mon, "jennifer"); // duplicate
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
table.column().second.add_search_index();
CHECK_EQUAL(true, table.column().second.has_search_index());
}
// Tests Table part of index on Int, OldDateTime and Bool columns. For a more exhaustive
// test of the integer index (bypassing Table), see test_index_string.cpp)
TEST(Table_IndexInteger)
{
Table table;
size_t r;
table.add_column(type_Int, "ints");
table.add_column(type_OldDateTime, "date");
table.add_column(type_Bool, "date");
table.add_empty_row(13);
table.set_int(0, 0, 3); // 0
table.set_int(0, 1, 1); // 1
table.set_int(0, 2, 2); // 2
table.set_int(0, 3, 2); // 3
table.set_int(0, 4, 2); // 4
table.set_int(0, 5, 3); // 5
table.set_int(0, 6, 3); // 6
table.set_int(0, 7, 2); // 7
table.set_int(0, 8, 4); // 8
table.set_int(0, 9, 2); // 9
table.set_int(0, 10, 6); // 10
table.set_int(0, 11, 2); // 11
table.set_int(0, 12, 3); // 12
table.add_search_index(0);
CHECK(table.has_search_index(0));
table.add_search_index(1);
CHECK(table.has_search_index(1));
table.add_search_index(2);
CHECK(table.has_search_index(2));
table.set_olddatetime(1, 10, OldDateTime(43));
r = table.find_first_olddatetime(1, OldDateTime(43));
CHECK_EQUAL(10, r);
table.set_bool(2, 11, true);
r = table.find_first_bool(2, true);
CHECK_EQUAL(11, r);
r = table.find_first_int(0, 11);
CHECK_EQUAL(not_found, r);
r = table.find_first_int(0, 3);
CHECK_EQUAL(0, r);
r = table.find_first_int(0, 4);
CHECK_EQUAL(8, r);
TableView tv = table.find_all_int(0, 2);
CHECK_EQUAL(6, tv.size());
CHECK_EQUAL(2, tv[0].get_index());
CHECK_EQUAL(3, tv[1].get_index());
CHECK_EQUAL(4, tv[2].get_index());
CHECK_EQUAL(7, tv[3].get_index());
CHECK_EQUAL(9, tv[4].get_index());
CHECK_EQUAL(11, tv[5].get_index());
}
TEST(Table_SetIntUnique)
{
Table table;
table.add_column(type_Int, "ints");
table.add_column(type_Int, "ints_null", true);
table.add_column(type_Int, "ints_null", true);
table.add_empty_row(10);
CHECK_LOGIC_ERROR(table.set_int_unique(0, 0, 123), LogicError::no_search_index);
CHECK_LOGIC_ERROR(table.set_int_unique(1, 0, 123), LogicError::no_search_index);
CHECK_LOGIC_ERROR(table.set_null_unique(2, 0), LogicError::no_search_index);
table.add_search_index(0);
table.add_search_index(1);
table.add_search_index(2);
table.set_int_unique(0, 0, 123);
CHECK_EQUAL(table.size(), 10);
table.set_int_unique(1, 0, 123);
CHECK_EQUAL(table.size(), 10);
table.set_int_unique(2, 0, 123);
CHECK_EQUAL(table.size(), 10);
// Check that conflicting SetIntUniques result in rows being deleted. First a collision in column 0:
table.set_int_unique(0, 1, 123); // This will delete row 1
CHECK_EQUAL(table.size(), 9);
table.set_int_unique(1, 1, 123); // This will delete row 1
CHECK_EQUAL(table.size(), 8);
table.set_int_unique(1, 2, 123); // This will delete row 1
CHECK_EQUAL(table.size(), 7);
// Collision in column 1:
table.set_int_unique(1, 0, 123); // no-op
CHECK_EQUAL(table.size(), 7);
table.set_int_unique(0, 0, 123); // no-op
CHECK_EQUAL(table.size(), 7);
table.set_int_unique(2, 0, 123); // no-op
CHECK_EQUAL(table.size(), 7);
// Collision in column 2:
table.set_int_unique(2, 1, 123); // This will delete a row
CHECK_EQUAL(table.size(), 6);
table.set_int_unique(0, 1, 123); // This will delete a row
CHECK_EQUAL(table.size(), 5);
table.set_int_unique(1, 1, 123); // This will delete a row
CHECK_EQUAL(table.size(), 4);
// Since table.add_empty_row(10); filled the column with all nulls, only two rows should now remain
table.set_null_unique(2, 1);
CHECK_EQUAL(table.size(), 2);
table.set_null_unique(2, 0);
CHECK_EQUAL(table.size(), 1);
}
TEST_TYPES(Table_SetStringUnique, std::true_type, std::false_type)
{
bool string_enum_column = TEST_TYPE::value;
Table table;
table.add_column(type_Int, "ints");
table.add_column(type_String, "strings");
table.add_column(type_String, "strings_nullable", true);
table.add_empty_row(10); // all duplicates!
CHECK_LOGIC_ERROR(table.set_string_unique(1, 0, "foo"), LogicError::no_search_index);
CHECK_LOGIC_ERROR(table.set_string_unique(2, 0, "foo"), LogicError::no_search_index);
table.add_search_index(1);
table.add_search_index(2);
if (string_enum_column) {
bool force = true;
table.optimize(force);
}
table.set_string_unique(1, 0, "bar");
// Check that conflicting SetStringUniques result in rows with duplicate values being deleted.
table.set_string_unique(1, 1, "bar");
CHECK_EQUAL(table.size(), 9); // Only duplicates of "bar" are removed.
table.set_string_unique(2, 0, realm::null());
CHECK_EQUAL(table.size(), 1);
}
TEST(Table_AddInt)
{
Table t;
t.add_column(type_Int, "i");
t.add_column(type_Int, "ni", /*nullable*/ true);
t.add_empty_row(1);
t.add_int(0, 0, 1);
CHECK_EQUAL(t.get_int(0, 0), 1);
// Check that signed integers wrap around. This invariant is necessary for
// full commutativity.
t.add_int(0, 0, Table::max_integer);
CHECK_EQUAL(t.get_int(0, 0), Table::min_integer);
t.add_int(0, 0, -1);
CHECK_EQUAL(t.get_int(0, 0), Table::max_integer);
// add_int() has no effect on a NULL
CHECK(t.is_null(1, 0));
CHECK_LOGIC_ERROR(t.add_int(1, 0, 123), LogicError::illegal_combination);
}
TEST(Table_SetUniqueAccessorUpdating)
{
Group g;
TableRef origin = g.add_table("origin");
TableRef target = g.add_table("target");
target->add_column(type_Int, "col");
origin->add_column(type_Int, "pk");
origin->add_column_link(type_LinkList, "list", *target);
origin->add_search_index(0);
origin->add_empty_row(2);
origin->set_int_unique(0, 0, 1);
origin->set_int_unique(0, 1, 2);
Row row_0 = (*origin)[0];
Row row_1 = (*origin)[1];
LinkViewRef lv_0 = origin->get_linklist(1, 0);
LinkViewRef lv_1 = origin->get_linklist(1, 1);
// check new row number > old row number
origin->add_empty_row(2);
// leaves row 0 as winner, move last over of 2
origin->set_int_unique(0, 2, 1);
CHECK_EQUAL(origin->size(), 3);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK_EQUAL(row_0.get_index(), 0);
CHECK_EQUAL(row_1.get_index(), 1);
CHECK(lv_0->is_attached());
CHECK(lv_1->is_attached());
CHECK(lv_0 == origin->get_linklist(1, 0));
CHECK(lv_1 == origin->get_linklist(1, 1));
// check new row number < old row number
origin->insert_empty_row(0, 2);
CHECK_EQUAL(origin->size(), 5);
// winner is row 3, row 0 is deleted via move_last_over(0)
origin->set_int_unique(0, 0, 2);
CHECK_EQUAL(origin->size(), 4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK_EQUAL(row_0.get_index(), 2); // unchanged
CHECK_EQUAL(row_1.get_index(), 3); // unchanged
CHECK(lv_0->is_attached());
CHECK(lv_1->is_attached());
CHECK(lv_0 == origin->get_linklist(1, 2));
CHECK(lv_1 == origin->get_linklist(1, 3));
}
TEST(Table_SetUniqueLoserAccessorUpdates)
{
Group g;
TableRef origin = g.add_table("origin");
TableRef target = g.add_table("target");
target->add_column(type_Int, "col");
target->add_empty_row(6);
size_t int_col = origin->add_column(type_Int, "pk");
size_t ll_col = origin->add_column_link(type_LinkList, "list", *target);
size_t str_col = origin->add_column(type_String, "description");
origin->add_search_index(0);
origin->add_search_index(2);
origin->add_empty_row(4);
origin->set_int_unique(int_col, 0, 1);
origin->set_int_unique(int_col, 1, 2);
origin->set_string(str_col, 0, "zero");
origin->set_string(str_col, 1, "one");
origin->set_string(str_col, 2, "two");
origin->set_string(str_col, 3, "three");
Row row_0 = (*origin)[0];
Row row_1 = (*origin)[1];
Row row_2 = (*origin)[2];
LinkViewRef lv_0 = origin->get_linklist(ll_col, 0);
LinkViewRef lv_1 = origin->get_linklist(ll_col, 1);
lv_0->add(0); // one link
lv_1->add(1); // two links
lv_1->add(2);
CHECK_EQUAL(origin->size(), 4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(row_0.get_string(str_col), "zero");
CHECK_EQUAL(row_1.get_string(str_col), "one");
CHECK_EQUAL(row_2.get_string(str_col), "two");
// leaves row 0 as winner, move last over of 2
origin->set_int_unique(int_col, 2, 1);
CHECK_EQUAL(origin->size(), 3);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(row_0.get_index(), 0);
CHECK_EQUAL(row_1.get_index(), 1);
CHECK_EQUAL(row_2.get_index(), 0);
CHECK_EQUAL(row_0.get_string(str_col), "zero");
CHECK_EQUAL(row_1.get_string(str_col), "one");
CHECK_EQUAL(row_2.get_string(str_col), "zero");
CHECK_EQUAL(row_0.get_linklist(ll_col)->size(), 1);
CHECK_EQUAL(row_1.get_linklist(ll_col)->size(), 2);
CHECK_EQUAL(row_2.get_linklist(ll_col)->size(), 1); // subsumed
CHECK_EQUAL(lv_0->size(), 1);
CHECK_EQUAL(lv_1->size(), 2);
CHECK(lv_0->is_attached());
CHECK(lv_1->is_attached());
CHECK(lv_0 == origin->get_linklist(1, 0));
CHECK(lv_1 == origin->get_linklist(1, 1));
}
TEST(Table_Distinct)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().second.add_search_index();
CHECK(table.column().second.has_search_index());
TestTableEnum::View view = table.column().second.get_distinct_view();
CHECK_EQUAL(4, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(5, view.get_source_ndx(3));
}
TEST(Table_DistinctEnums)
{
TestTableEnum table;
table.add(Mon, "A");
table.add(Tue, "B");
table.add(Wed, "C");
table.add(Thu, "B");
table.add(Fri, "C");
table.add(Sat, "D");
table.add(Sun, "D");
table.add(Mon, "D");
table.column().first.add_search_index();
CHECK(table.column().first.has_search_index());
TestTableEnum::View view = table.column().first.get_distinct_view();
CHECK_EQUAL(7, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
CHECK_EQUAL(3, view.get_source_ndx(3));
CHECK_EQUAL(4, view.get_source_ndx(4));
CHECK_EQUAL(5, view.get_source_ndx(5));
CHECK_EQUAL(6, view.get_source_ndx(6));
}
TEST(Table_DistinctIntegers)
{
Table table;
table.add_column(type_Int, "first");
table.add_empty_row(4);
table.set_int(0, 0, 1);
table.set_int(0, 1, 2);
table.set_int(0, 2, 3);
table.set_int(0, 3, 3);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
TEST(Table_DistinctBool)
{
Table table;
table.add_column(type_Bool, "first");
table.add_empty_row(4);
table.set_bool(0, 0, true);
table.set_bool(0, 1, false);
table.set_bool(0, 2, true);
table.set_bool(0, 3, false);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(2, view.size());
CHECK_EQUAL(0, view.get_source_ndx(1));
CHECK_EQUAL(1, view.get_source_ndx(0));
}
/*
// FIXME Commented out because indexes on floats and doubles are not supported (yet).
TEST(Table_DistinctFloat)
{
Table table;
table.add_column(type_Float, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_float(0, i, static_cast<float>(i) + 0.5f);
}
table.set_float(0, 10, 0.5f);
table.set_float(0, 11, 1.5f);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
TEST(Table_DistinctDouble)
{
Table table;
table.add_column(type_Double, "first");
table.add_empty_row(12);
for (size_t i = 0; i < 10; ++i) {
table.set_double(0, i, static_cast<double>(i) + 0.5);
}
table.set_double(0, 10, 0.5);
table.set_double(0, 11, 1.5);
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(10, view.size());
}
*/
TEST(Table_DistinctDateTime)
{
Table table;
table.add_column(type_OldDateTime, "first");
table.add_empty_row(4);
table.set_olddatetime(0, 0, OldDateTime(0));
table.set_olddatetime(0, 1, OldDateTime(1));
table.set_olddatetime(0, 2, OldDateTime(3));
table.set_olddatetime(0, 3, OldDateTime(3));
table.add_search_index(0);
CHECK(table.has_search_index(0));
TableView view = table.get_distinct_view(0);
CHECK_EQUAL(3, view.size());
}
TEST(Table_DistinctFromPersistedTable)
{
GROUP_TEST_PATH(path);
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "first");
table->add_empty_row(4);
table->set_int(0, 0, 1);
table->set_int(0, 1, 2);
table->set_int(0, 2, 3);
table->set_int(0, 3, 3);
table->add_search_index(0);
CHECK(table->has_search_index(0));
group.write(path);
}
{
Group group(path, 0, Group::mode_ReadOnly);
TableRef table = group.get_table("table");
TableView view = table->get_distinct_view(0);
CHECK_EQUAL(3, view.size());
CHECK_EQUAL(0, view.get_source_ndx(0));
CHECK_EQUAL(1, view.get_source_ndx(1));
CHECK_EQUAL(2, view.get_source_ndx(2));
}
}
TEST(Table_IndexInt)
{
TestTable table;
table.add(0, 1, true, Wed);
table.add(0, 15, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 20, true, Wed);
table.add(0, 11, true, Wed);
table.add(0, 45, true, Wed);
table.add(0, 10, true, Wed);
table.add(0, 0, true, Wed);
table.add(0, 30, true, Wed);
table.add(0, 9, true, Wed);
// Create index for column two
table.column().second.add_search_index();
// Search for a value that does not exits
const size_t r1 = table.column().second.find_first(2);
CHECK_EQUAL(npos, r1);
// Find existing values
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(10));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
// CHECK_EQUAL(6, table.column().second.find_first(10)); // only finds first match
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(9));
// Change some values
table[2].second = 13;
table[9].second = 100;
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
// Insert values
table.add(0, 29, true, Wed);
// TODO: More than add
CHECK_EQUAL(0, table.column().second.find_first(1));
CHECK_EQUAL(1, table.column().second.find_first(15));
CHECK_EQUAL(2, table.column().second.find_first(13));
CHECK_EQUAL(3, table.column().second.find_first(20));
CHECK_EQUAL(4, table.column().second.find_first(11));
CHECK_EQUAL(5, table.column().second.find_first(45));
CHECK_EQUAL(6, table.column().second.find_first(10));
CHECK_EQUAL(7, table.column().second.find_first(0));
CHECK_EQUAL(8, table.column().second.find_first(30));
CHECK_EQUAL(9, table.column().second.find_first(100));
CHECK_EQUAL(10, table.column().second.find_first(29));
// Delete some values
table.remove(0);
table.remove(5);
table.remove(8);
CHECK_EQUAL(0, table.column().second.find_first(15));
CHECK_EQUAL(1, table.column().second.find_first(13));
CHECK_EQUAL(2, table.column().second.find_first(20));
CHECK_EQUAL(3, table.column().second.find_first(11));
CHECK_EQUAL(4, table.column().second.find_first(45));
CHECK_EQUAL(5, table.column().second.find_first(0));
CHECK_EQUAL(6, table.column().second.find_first(30));
CHECK_EQUAL(7, table.column().second.find_first(100));
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_4(TestTableAE, first, Int, second, String, third, Bool, fourth, Enum<Days>)
} // anonymous namespace
TEST(Table_AutoEnumeration)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
for (size_t i = 0; i < 5; ++i) {
const size_t n = i * 5;
CHECK_EQUAL(1, table[0 + n].first);
CHECK_EQUAL(2, table[1 + n].first);
CHECK_EQUAL(5, table[2 + n].first);
CHECK_EQUAL(8, table[3 + n].first);
CHECK_EQUAL(9, table[4 + n].first);
CHECK_EQUAL("abd", table[0 + n].second);
CHECK_EQUAL("eftg", table[1 + n].second);
CHECK_EQUAL("hijkl", table[2 + n].second);
CHECK_EQUAL("mnopqr", table[3 + n].second);
CHECK_EQUAL("stuvxyz", table[4 + n].second);
CHECK_EQUAL(true, table[0 + n].third);
CHECK_EQUAL(true, table[1 + n].third);
CHECK_EQUAL(true, table[2 + n].third);
CHECK_EQUAL(true, table[3 + n].third);
CHECK_EQUAL(true, table[4 + n].third);
CHECK_EQUAL(Mon, table[0 + n].fourth);
CHECK_EQUAL(Tue, table[1 + n].fourth);
CHECK_EQUAL(Wed, table[2 + n].fourth);
CHECK_EQUAL(Thu, table[3 + n].fourth);
CHECK_EQUAL(Fri, table[4 + n].fourth);
}
// Verify counts
const size_t count1 = table.column().second.count("abd");
const size_t count2 = table.column().second.count("eftg");
const size_t count3 = table.column().second.count("hijkl");
const size_t count4 = table.column().second.count("mnopqr");
const size_t count5 = table.column().second.count("stuvxyz");
CHECK_EQUAL(5, count1);
CHECK_EQUAL(5, count2);
CHECK_EQUAL(5, count3);
CHECK_EQUAL(5, count4);
CHECK_EQUAL(5, count5);
}
TEST(Table_AutoEnumerationFindFindAll)
{
TestTableAE table;
for (size_t i = 0; i < 5; ++i) {
table.add(1, "abd", true, Mon);
table.add(2, "eftg", true, Tue);
table.add(5, "hijkl", true, Wed);
table.add(8, "mnopqr", true, Thu);
table.add(9, "stuvxyz", true, Fri);
}
table.optimize();
size_t t = table.column().second.find_first("eftg");
CHECK_EQUAL(1, t);
TestTableAE::View tv = table.column().second.find_all("eftg");
CHECK_EQUAL(5, tv.size());
CHECK_EQUAL("eftg", tv[0].second);
CHECK_EQUAL("eftg", tv[1].second);
CHECK_EQUAL("eftg", tv[2].second);
CHECK_EQUAL("eftg", tv[3].second);
CHECK_EQUAL("eftg", tv[4].second);
}
namespace {
REALM_TABLE_4(TestTableEnum4, col1, String, col2, String, col3, String, col4, String)
} // anonymous namespace
TEST(Table_AutoEnumerationOptimize)
{
TestTableEnum4 t;
// Insert non-optimzable strings
std::string s;
for (size_t i = 0; i < 10; ++i) {
t.add(s.c_str(), s.c_str(), s.c_str(), s.c_str());
s += "x";
}
t.optimize();
// AutoEnumerate in reverse order
for (size_t i = 0; i < 10; ++i) {
t[i].col4 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col3 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col2 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
t[i].col1 = "test";
}
t.optimize();
for (size_t i = 0; i < 10; ++i) {
CHECK_EQUAL("test", t[i].col1);
CHECK_EQUAL("test", t[i].col2);
CHECK_EQUAL("test", t[i].col3);
CHECK_EQUAL("test", t[i].col4);
}
#ifdef REALM_DEBUG
t.verify();
#endif
}
namespace {
REALM_TABLE_1(TestSubtabEnum2, str, String)
REALM_TABLE_1(TestSubtabEnum1, subtab, Subtable<TestSubtabEnum2>)
} // anonymous namespace
TEST(Table_OptimizeSubtable)
{
TestSubtabEnum1 t;
t.add();
t.add();
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (int i = 0; i < 100; ++i) {
r->add(s.c_str());
s += 'x';
}
}
{
// Enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (int i = 0; i < 100; ++i) {
r->add("foo");
}
r->optimize();
}
// Verify
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[0].subtab;
std::string s;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL(s.c_str(), r[i].str);
s += 'x';
}
}
{
// Non-enumerable
TestSubtabEnum2::Ref r = t[1].subtab;
for (size_t i = 0; i < r->size(); ++i) {
CHECK_EQUAL("foo", r[i].str);
}
}
}
TEST(Table_OptimizeCompare)
{
TestSubtabEnum2 t1, t2;
for (int i = 0; i < 100; ++i) {
t1.add("foo");
}
for (int i = 0; i < 100; ++i) {
t2.add("foo");
}
t1.optimize();
CHECK(t1 == t2);
t1[50].str = "bar";
CHECK(t1 != t2);
t1[50].str = "foo";
CHECK(t1 == t2);
t2[50].str = "bar";
CHECK(t1 != t2);
t2[50].str = "foo";
CHECK(t1 == t2);
}
TEST(Table_SlabAlloc)
{
SlabAlloc alloc;
alloc.attach_empty();
TestTable table(alloc);
table.add(0, 10, true, Wed);
const TestTable::Cursor r = table.back(); // last item
CHECK_EQUAL(0, r.first);
CHECK_EQUAL(10, r.second);
CHECK_EQUAL(true, r.third);
CHECK_EQUAL(Wed, r.fourth);
// Add some more rows
table.add(1, 10, true, Wed);
table.add(2, 20, true, Wed);
table.add(3, 10, true, Wed);
table.add(4, 20, true, Wed);
table.add(5, 10, true, Wed);
// Delete some rows
table.remove(2);
table.remove(4);
#ifdef REALM_DEBUG
table.verify();
#endif
}
TEST(Table_Spec)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
{
DescriptorRef sub_1;
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third", &sub_1);
sub_1->add_column(type_Int, "sub_first");
sub_1->add_column(type_String, "sub_second");
}
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Write the group to disk
GROUP_TEST_PATH(path);
group.write(path);
// Read back tables
{
Group from_disk(path, 0, Group::mode_ReadOnly);
TableRef from_disk_table = from_disk.get_table("test");
TableRef subtable2 = from_disk_table->get_subtable(2, 0);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("test", subtable2->get_string(1, 0));
}
}
TEST(Table_SpecColumnPath)
{
Group group;
TableRef table = group.add_table("test");
// Create path to sub-table column (starting with root)
std::vector<size_t> column_path;
// Create specification with sub-table
table->add_subcolumn(column_path, type_Int, "first");
table->add_subcolumn(column_path, type_String, "second");
table->add_subcolumn(column_path, type_Table, "third");
column_path.push_back(2); // third column (which is a sub-table col)
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
}
TEST(Table_SpecRenameColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Rename first column
table->rename_column(0, "1st");
CHECK_EQUAL(0, table->get_column_index("1st"));
// Rename sub-column
table->rename_subcolumn(column_path, 0, "sub_1st"); // third
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(0, subtable->get_column_index("sub_1st"));
}
}
TEST(Table_SpecDeleteColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
table->add_column(type_String, "fourth"); // will be auto-enumerated
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(4, table->get_column_count());
// Add a few rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->set_string(3, 0, "X");
table->insert_empty_row(1);
table->set_int(0, 1, 4);
table->set_string(1, 1, "World");
table->set_string(3, 1, "X");
table->insert_empty_row(2);
table->set_int(0, 2, 4);
table->set_string(1, 2, "Goodbye");
table->set_string(3, 2, "X");
// We want the last column to be StringEnum column
table->optimize();
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Remove the first column
table->remove_column(0);
CHECK_EQUAL(3, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(2, 0));
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(2, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
// Create path to column in sub-table
column_path.clear();
column_path.push_back(1); // third
// Remove a column in sub-table
table->remove_subcolumn(column_path, 1); // sub_second
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(1, 0);
CHECK_EQUAL(1, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
}
// Remove sub-table column (with all members)
table->remove_column(1);
CHECK_EQUAL(2, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
CHECK_EQUAL("X", table->get_string(1, 0));
// Remove optimized string column
table->remove_column(1);
CHECK_EQUAL(1, table->get_column_count());
CHECK_EQUAL("Hello", table->get_string(0, 0));
// Remove last column
table->remove_column(0);
CHECK_EQUAL(0, table->get_column_count());
CHECK(table->is_empty());
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_SpecMoveColumns)
{
using df = _impl::DescriptorFriend;
Group group;
TableRef foo = group.add_table("foo");
foo->add_column(type_Int, "a");
foo->add_column(type_Float, "b");
foo->add_column(type_Table, "c");
DescriptorRef foo_descriptor = foo->get_descriptor();
DescriptorRef c_descriptor = foo_descriptor->get_subdescriptor(2);
c_descriptor->add_column(type_Int, "c_a");
c_descriptor->add_column(type_Float, "c_b");
foo->add_empty_row();
foo->add_empty_row();
TableRef subtable0 = foo->get_subtable(2, 0);
subtable0->add_empty_row();
subtable0->set_int(0, 0, 123);
df::move_column(*foo_descriptor, 0, 2);
CHECK_EQUAL(foo_descriptor->get_column_type(1), type_Table);
CHECK_EQUAL(foo_descriptor->get_column_name(1), "c");
CHECK(c_descriptor->is_attached());
CHECK(subtable0->is_attached());
CHECK_EQUAL(123, subtable0->get_int(0, 0));
TableRef subtable1 = foo->get_subtable(1, 1);
subtable1->add_empty_row();
subtable1->set_int(0, 0, 456);
df::move_column(*c_descriptor, 0, 1);
CHECK(subtable0->is_attached());
CHECK(subtable1->is_attached());
CHECK_EQUAL(subtable0->get_int(1, 0), 123);
CHECK_EQUAL(subtable1->get_int(1, 0), 456);
}
TEST(Table_SpecMoveLinkColumn)
{
using df = _impl::DescriptorFriend;
Group group;
TableRef target = group.add_table("target");
target->add_column(type_Int, "a");
TableRef origin = group.add_table("origin");
origin->add_column_link(type_Link, "a", *target);
origin->add_column(type_Int, "b");
origin->add_empty_row(2);
target->add_empty_row(2);
origin->set_link(0, 0, 1);
df::move_column(*origin->get_descriptor(), 0, 1);
CHECK_EQUAL(origin->get_link(1, 0), 1);
CHECK_EQUAL(target->get_backlink_count(0, *origin, 1), 0);
CHECK_EQUAL(target->get_backlink_count(1, *origin, 1), 1);
}
TEST(Table_SpecMoveColumnsWithIndexes)
{
using df = _impl::DescriptorFriend;
using tf = _impl::TableFriend;
Group group;
TableRef foo = group.add_table("foo");
DescriptorRef desc = foo->get_descriptor();
foo->add_column(type_Int, "a");
foo->add_search_index(0);
foo->add_column(type_Int, "b");
StringIndex* a_index = tf::get_column(*foo, 0).get_search_index();
CHECK_EQUAL(1, a_index->get_ndx_in_parent());
df::move_column(*desc, 0, 1);
CHECK_EQUAL(2, a_index->get_ndx_in_parent());
auto& spec = df::get_spec(*desc);
CHECK(foo->has_search_index(1));
CHECK((spec.get_column_attr(1) & col_attr_Indexed));
CHECK(!foo->has_search_index(0));
CHECK(!(spec.get_column_attr(0) & col_attr_Indexed));
foo->add_column(type_Int, "c");
foo->add_search_index(0);
StringIndex* b_index = tf::get_column(*foo, 0).get_search_index();
CHECK_EQUAL(1, b_index->get_ndx_in_parent());
CHECK_EQUAL(3, a_index->get_ndx_in_parent());
df::move_column(*desc, 0, 1);
CHECK(foo->has_search_index(0));
CHECK((spec.get_column_attr(0) & col_attr_Indexed));
CHECK(foo->has_search_index(1));
CHECK((spec.get_column_attr(1) & col_attr_Indexed));
CHECK(!foo->has_search_index(2));
CHECK(!(spec.get_column_attr(2) & col_attr_Indexed));
CHECK_EQUAL(1, a_index->get_ndx_in_parent());
CHECK_EQUAL(3, b_index->get_ndx_in_parent());
df::move_column(*desc, 2, 0);
CHECK(!foo->has_search_index(0));
CHECK(!(spec.get_column_attr(0) & col_attr_Indexed));
CHECK(foo->has_search_index(1));
CHECK((spec.get_column_attr(1) & col_attr_Indexed));
CHECK(foo->has_search_index(2));
CHECK((spec.get_column_attr(2) & col_attr_Indexed));
CHECK_EQUAL(2, a_index->get_ndx_in_parent());
CHECK_EQUAL(4, b_index->get_ndx_in_parent());
df::move_column(*desc, 1, 0);
CHECK(foo->has_search_index(0));
CHECK((spec.get_column_attr(0) & col_attr_Indexed));
CHECK(!foo->has_search_index(1));
CHECK(!(spec.get_column_attr(1) & col_attr_Indexed));
CHECK(foo->has_search_index(2));
CHECK((spec.get_column_attr(2) & col_attr_Indexed));
CHECK_EQUAL(1, a_index->get_ndx_in_parent());
CHECK_EQUAL(4, b_index->get_ndx_in_parent());
}
TEST(Table_NullInEnum)
{
Group group;
TableRef table = group.add_table("test");
table->add_column(type_String, "second", true);
for (size_t c = 0; c < 100; c++) {
table->insert_empty_row(c);
table->set_string(0, c, "hello");
}
size_t r;
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->optimize();
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
table->set_string(0, 50, "hello");
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(100, r);
table->set_string(0, 50, realm::null());
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(99, r);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
table->set_string(0, 55, realm::null());
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(2, r);
r = table->where().equal(0, "hello").count();
CHECK_EQUAL(98, r);
table->remove(55);
r = table->where().equal(0, realm::null()).count();
CHECK_EQUAL(1, r);
}
TEST(Table_SpecAddColumns)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Put in an index as well
table->add_search_index(1);
CHECK_EQUAL(3, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
CHECK_EQUAL(0, table->get_subtable_size(2, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 42);
subtable->set_string(1, 0, "test");
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
// Add a new bool column
table->add_column(type_Bool, "fourth");
CHECK_EQUAL(4, table->get_column_count());
CHECK_EQUAL(false, table->get_bool(3, 0));
// Add a new string column
table->add_column(type_String, "fifth");
CHECK_EQUAL(5, table->get_column_count());
CHECK_EQUAL("", table->get_string(4, 0));
// Add a new table column
table->add_column(type_Table, "sixth");
CHECK_EQUAL(6, table->get_column_count());
CHECK_EQUAL(0, table->get_subtable_size(5, 0));
// Add a new mixed column
table->add_column(type_Mixed, "seventh");
CHECK_EQUAL(7, table->get_column_count());
CHECK_EQUAL(0, table->get_mixed(6, 0).get_int());
// Create path to column in sub-table
column_path.clear();
column_path.push_back(2); // third
// Add new int column to sub-table
table->add_subcolumn(column_path, type_Int, "sub_third");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(3, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
}
// Add new table column to sub-table
table->add_subcolumn(column_path, type_Table, "sub_fourth");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
CHECK_EQUAL(1, subtable->size());
CHECK_EQUAL(42, subtable->get_int(0, 0));
CHECK_EQUAL("test", subtable->get_string(1, 0));
CHECK_EQUAL(0, subtable->get_int(2, 0));
CHECK_EQUAL(0, subtable->get_subtable_size(3, 0));
CHECK_EQUAL(1, table->get_subtable_size(2, 0));
}
// Add new column to new sub-table
column_path.push_back(3); // sub_forth
table->add_subcolumn(column_path, type_String, "first");
// Get the sub-table again and see if the values
// still match.
{
TableRef subtable = table->get_subtable(2, 0);
CHECK_EQUAL(4, subtable->get_column_count());
TableRef subsubtable = subtable->get_subtable(3, 0);
CHECK_EQUAL(1, subsubtable->get_column_count());
}
// Add a new mixed column
table->add_column(type_Mixed, "eighth");
CHECK_EQUAL(8, table->get_column_count());
table->set_mixed(7, 0, Mixed::subtable_tag());
TableRef stab = table->get_subtable(7, 0);
stab->add_column(type_Int, "smurf");
stab->insert_empty_row(0);
stab->set_int(0, 0, 1);
stab->insert_empty_row(1);
stab->set_int(0, 1, 2);
CHECK_EQUAL(2, table->get_subtable_size(7, 0));
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_SpecDeleteColumnsBug)
{
TableRef table = Table::create();
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_search_index(0);
table->add_column(type_Int, "age");
table->add_column(type_Bool, "hired");
table->add_column(type_Table, "phones");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(3); // phones
table->add_subcolumn(column_path, type_String, "type");
table->add_subcolumn(column_path, type_String, "number");
// Add rows
table->add_empty_row();
table->set_string(0, 0, "jessica");
table->set_int(1, 0, 22);
table->set_bool(2, 0, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "232-323-3242");
}
table->add_empty_row();
table->set_string(0, 1, "joe");
table->set_int(1, 1, 42);
table->set_bool(2, 1, false);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "work");
phones->set_string(1, 0, "434-434-4343");
}
table->add_empty_row();
table->set_string(0, 1, "jared");
table->set_int(1, 1, 35);
table->set_bool(2, 1, true);
{
TableRef phones = table->get_subtable(3, 0);
phones->add_empty_row();
phones->set_string(0, 0, "home");
phones->set_string(1, 0, "342-323-3242");
phones->add_empty_row();
phones->set_string(0, 0, "school");
phones->set_string(1, 0, "434-432-5433");
}
// Add new column
table->add_column(type_Mixed, "extra");
table->set_mixed(4, 0, true);
table->set_mixed(4, 2, "Random string!");
// Remove some columns
table->remove_column(1); // age
table->remove_column(3); // extra
#ifdef REALM_DEBUG
table->verify();
#endif
}
TEST(Table_Mixed)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Mixed, "second");
CHECK_EQUAL(type_Int, table.get_column_type(0));
CHECK_EQUAL(type_Mixed, table.get_column_type(1));
CHECK_EQUAL("first", table.get_column_name(0));
CHECK_EQUAL("second", table.get_column_name(1));
const size_t ndx = table.add_empty_row();
table.set_int(0, ndx, 0);
table.set_mixed(1, ndx, true);
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
table.insert_empty_row(1);
table.set_int(0, 1, 43);
table.set_mixed(1, 1, int64_t(12));
CHECK_EQUAL(0, table.get_int(0, ndx));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
table.insert_empty_row(2);
table.set_int(0, 2, 100);
table.set_mixed(1, 2, "test");
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
table.insert_empty_row(3);
table.set_int(0, 3, 0);
table.set_mixed(1, 3, OldDateTime(324234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
table.insert_empty_row(4);
table.set_int(0, 4, 43);
table.set_mixed(1, 4, Mixed(BinaryData("binary", 7)));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
table.insert_empty_row(5);
table.set_int(0, 5, 0);
table.set_mixed(1, 5, Mixed::subtable_tag());
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
// Get table from mixed column and add schema and some values
TableRef subtable = table.get_subtable(1, 5);
subtable->add_column(type_String, "name");
subtable->add_column(type_Int, "age");
subtable->insert_empty_row(0);
subtable->set_string(0, 0, "John");
subtable->set_int(1, 0, 40);
// Get same table again and verify values
TableRef subtable2 = table.get_subtable(1, 5);
CHECK_EQUAL(1, subtable2->size());
CHECK_EQUAL("John", subtable2->get_string(0, 0));
CHECK_EQUAL(40, subtable2->get_int(1, 0));
// Insert float, double
table.insert_empty_row(6);
table.set_int(0, 6, 31);
table.set_mixed(1, 6, float(1.123));
table.insert_empty_row(7);
table.set_int(0, 7, 0);
table.set_mixed(1, 7, double(2.234));
CHECK_EQUAL(0, table.get_int(0, 0));
CHECK_EQUAL(43, table.get_int(0, 1));
CHECK_EQUAL(0, table.get_int(0, 3));
CHECK_EQUAL(43, table.get_int(0, 4));
CHECK_EQUAL(0, table.get_int(0, 5));
CHECK_EQUAL(31, table.get_int(0, 6));
CHECK_EQUAL(0, table.get_int(0, 7));
CHECK_EQUAL(type_Bool, table.get_mixed(1, 0).get_type());
CHECK_EQUAL(type_Int, table.get_mixed(1, 1).get_type());
CHECK_EQUAL(type_String, table.get_mixed(1, 2).get_type());
CHECK_EQUAL(type_OldDateTime, table.get_mixed(1, 3).get_type());
CHECK_EQUAL(type_Binary, table.get_mixed(1, 4).get_type());
CHECK_EQUAL(type_Table, table.get_mixed(1, 5).get_type());
CHECK_EQUAL(type_Float, table.get_mixed(1, 6).get_type());
CHECK_EQUAL(type_Double, table.get_mixed(1, 7).get_type());
CHECK_EQUAL(true, table.get_mixed(1, 0).get_bool());
CHECK_EQUAL(12, table.get_mixed(1, 1).get_int());
CHECK_EQUAL("test", table.get_mixed(1, 2).get_string());
CHECK_EQUAL(324234, table.get_mixed(1, 3).get_olddatetime());
CHECK_EQUAL("binary", table.get_mixed(1, 4).get_binary().data());
CHECK_EQUAL(7, table.get_mixed(1, 4).get_binary().size());
CHECK_EQUAL(float(1.123), table.get_mixed(1, 6).get_float());
CHECK_EQUAL(double(2.234), table.get_mixed(1, 7).get_double());
#ifdef REALM_DEBUG
table.verify();
#endif
}
namespace {
REALM_TABLE_1(TestTableMX, first, Mixed)
} // anonymous namespace
TEST(Table_Mixed2)
{
TestTableMX table;
table.add(int64_t(1));
table.add(true);
table.add(OldDateTime(1234));
table.add("test");
CHECK_EQUAL(type_Int, table[0].first.get_type());
CHECK_EQUAL(type_Bool, table[1].first.get_type());
CHECK_EQUAL(type_OldDateTime, table[2].first.get_type());
CHECK_EQUAL(type_String, table[3].first.get_type());
CHECK_EQUAL(1, table[0].first.get_int());
CHECK_EQUAL(true, table[1].first.get_bool());
CHECK_EQUAL(1234, table[2].first.get_olddatetime());
CHECK_EQUAL("test", table[3].first.get_string());
}
TEST(Table_SubtableSizeAndClear)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Table, "subtab", &subdesc);
table.add_column(type_Mixed, "mixed");
subdesc->add_column(type_Int, "int");
table.insert_empty_row(0);
table.insert_empty_row(1);
Table subtable;
table.set_mixed_subtable(1, 1, &subtable);
CHECK_EQUAL(0, table.get_subtable_size(0, 0)); // Subtable column
CHECK_EQUAL(0, table.get_subtable_size(1, 0)); // Mixed column, bool value
CHECK_EQUAL(0, table.get_subtable_size(1, 1)); // Mixed column, table value
CHECK(table.get_subtable(0, 0)); // Subtable column
CHECK(!table.get_subtable(1, 0)); // Mixed column, bool value, must return nullptr
CHECK(table.get_subtable(1, 1)); // Mixed column, table value
table.set_mixed(1, 0, Mixed::subtable_tag());
table.set_mixed(1, 1, false);
CHECK(table.get_subtable(1, 0));
CHECK(!table.get_subtable(1, 1));
TableRef subtab1 = table.get_subtable(0, 0);
TableRef subtab2 = table.get_subtable(1, 0);
subtab2->add_column(type_Int, "int");
CHECK_EQUAL(0, table.get_subtable_size(1, 0));
CHECK(table.get_subtable(1, 0));
subtab1->insert_empty_row(0);
subtab2->insert_empty_row(0);
CHECK_EQUAL(1, table.get_subtable_size(0, 0));
CHECK_EQUAL(1, table.get_subtable_size(1, 0));
table.clear_subtable(0, 0);
table.clear_subtable(1, 0);
CHECK_EQUAL(0, table.get_subtable_size(0, 0));
CHECK_EQUAL(0, table.get_subtable_size(1, 0));
CHECK(table.get_subtable(1, 0));
}
TEST(Table_LowLevelSubtables)
{
Table table;
std::vector<size_t> column_path;
table.add_column(type_Table, "subtab");
table.add_column(type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
column_path.push_back(0);
table.add_subcolumn(column_path, type_Table, "subtab");
table.add_subcolumn(column_path, type_Mixed, "mixed");
table.add_empty_row(2);
CHECK_EQUAL(2, table.size());
for (int i_1 = 0; i_1 != 2; ++i_1) {
TableRef subtab = table.get_subtable(0, i_1);
subtab->add_empty_row(2 + i_1);
CHECK_EQUAL(2 + i_1, subtab->size());
{
TableRef subsubtab = subtab->get_subtable(0, 0 + i_1);
subsubtab->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 3 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab->clear_subtable(1, 1 + i_1); // Mixed
TableRef subsubtab_mix = subtab->get_subtable(1, 1 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(1 + i_1);
CHECK_EQUAL(1 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 1 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 1 + i_1, bool(subtab->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 0 + i_1 ? 3 + i_1 : 0, subtab->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 1 + i_1 ? 1 + i_1 : 0, subtab->get_subtable_size(1, i_2)); // Mixed
}
table.clear_subtable(1, i_1); // Mixed
TableRef subtab_mix = table.get_subtable(1, i_1);
std::vector<size_t> subcol_path;
subtab_mix->add_column(type_Table, "subtab");
subtab_mix->add_column(type_Mixed, "mixed");
subcol_path.push_back(0);
subtab_mix->add_subcolumn(subcol_path, type_Table, "subtab");
subtab_mix->add_subcolumn(subcol_path, type_Mixed, "mixed");
subtab_mix->add_empty_row(3 + i_1);
CHECK_EQUAL(3 + i_1, subtab_mix->size());
{
TableRef subsubtab = subtab_mix->get_subtable(0, 1 + i_1);
subsubtab->add_empty_row(7 + i_1);
CHECK_EQUAL(7 + i_1, subsubtab->size());
for (int i_3 = 0; i_3 != 7 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab->get_subtable_size(1, i_3)); // Mixed
}
subtab_mix->clear_subtable(1, 2 + i_1); // Mixed
TableRef subsubtab_mix = subtab_mix->get_subtable(1, 2 + i_1);
subsubtab_mix->add_column(type_Table, "subtab");
subsubtab_mix->add_column(type_Mixed, "mixed");
subsubtab_mix->add_empty_row(5 + i_1);
CHECK_EQUAL(5 + i_1, subsubtab_mix->size());
for (int i_3 = 0; i_3 != 5 + i_1; ++i_3) {
CHECK_EQUAL(true, bool(subsubtab_mix->get_subtable(0, i_3)));
CHECK_EQUAL(false, bool(subsubtab_mix->get_subtable(1, i_3))); // Mixed
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(0, i_3));
CHECK_EQUAL(0, subsubtab_mix->get_subtable_size(1, i_3)); // Mixed
}
}
for (int i_2 = 0; i_2 != 2 + i_1; ++i_2) {
CHECK_EQUAL(true, bool(subtab_mix->get_subtable(0, i_2)));
CHECK_EQUAL(i_2 == 2 + i_1, bool(subtab_mix->get_subtable(1, i_2))); // Mixed
CHECK_EQUAL(i_2 == 1 + i_1 ? 7 + i_1 : 0, subtab_mix->get_subtable_size(0, i_2));
CHECK_EQUAL(i_2 == 2 + i_1 ? 5 + i_1 : 0, subtab_mix->get_subtable_size(1, i_2)); // Mixed
}
CHECK_EQUAL(true, bool(table.get_subtable(0, i_1)));
CHECK_EQUAL(true, bool(table.get_subtable(1, i_1))); // Mixed
CHECK_EQUAL(2 + i_1, table.get_subtable_size(0, i_1));
CHECK_EQUAL(3 + i_1, table.get_subtable_size(1, i_1)); // Mixed
}
}
namespace {
REALM_TABLE_2(MyTable1, val, Int, val2, Int)
REALM_TABLE_2(MyTable2, val, Int, subtab, Subtable<MyTable1>)
REALM_TABLE_1(MyTable3, subtab, Subtable<MyTable2>)
REALM_TABLE_1(MyTable4, mix, Mixed)
} // anonymous namespace
TEST(Table_HighLevelSubtables)
{
MyTable3 t;
{
MyTable3::Ref r1 = t.get_table_ref();
MyTable3::ConstRef r2 = t.get_table_ref();
MyTable3::ConstRef r3 = r2->get_table_ref();
r3 = t.get_table_ref(); // Also test assigment that converts to const
static_cast<void>(r1);
static_cast<void>(r3);
}
t.add();
const MyTable3& ct = t;
{
MyTable2::Ref s1 = t[0].subtab;
MyTable2::ConstRef s2 = t[0].subtab;
MyTable2::Ref s3 = t[0].subtab->get_table_ref();
MyTable2::ConstRef s4 = t[0].subtab->get_table_ref();
MyTable2::Ref s5 = t.column().subtab[0];
MyTable2::ConstRef s6 = t.column().subtab[0];
MyTable2::Ref s7 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef s8 = t.column().subtab[0]->get_table_ref();
MyTable2::ConstRef cs1 = ct[0].subtab;
MyTable2::ConstRef cs2 = ct[0].subtab->get_table_ref();
MyTable2::ConstRef cs3 = ct.column().subtab[0];
MyTable2::ConstRef cs4 = ct.column().subtab[0]->get_table_ref();
s1 = t[0].subtab;
s2 = t[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab->add();
{
MyTable1::Ref s1 = t[0].subtab[0].subtab;
MyTable1::ConstRef s2 = t[0].subtab[0].subtab;
MyTable1::Ref s3 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef s4 = t[0].subtab[0].subtab->get_table_ref();
MyTable1::Ref s5 = t.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef s6 = t.column().subtab[0]->column().subtab[0];
MyTable1::Ref s7 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef s8 = t.column().subtab[0]->column().subtab[0]->get_table_ref();
MyTable1::ConstRef cs1 = ct[0].subtab[0].subtab;
MyTable1::ConstRef cs2 = ct[0].subtab[0].subtab->get_table_ref();
MyTable1::ConstRef cs3 = ct.column().subtab[0]->column().subtab[0];
MyTable1::ConstRef cs4 = ct.column().subtab[0]->column().subtab[0]->get_table_ref();
s1 = t[0].subtab[0].subtab;
s2 = t[0].subtab[0].subtab; // Also test assigment that converts to const
static_cast<void>(s1);
static_cast<void>(s2);
static_cast<void>(s3);
static_cast<void>(s4);
static_cast<void>(s5);
static_cast<void>(s6);
static_cast<void>(s7);
static_cast<void>(s8);
static_cast<void>(cs1);
static_cast<void>(cs2);
static_cast<void>(cs3);
static_cast<void>(cs4);
}
t[0].subtab[0].val = 1;
CHECK_EQUAL(t[0].subtab[0].val, 1);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 1);
CHECK_EQUAL(t[0].subtab->column().val[0], 1);
CHECK_EQUAL(t.column().subtab[0][0].val, 1);
t.column().subtab[0]->column().val[0] = 2;
CHECK_EQUAL(t[0].subtab[0].val, 2);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 2);
CHECK_EQUAL(t[0].subtab->column().val[0], 2);
CHECK_EQUAL(t.column().subtab[0][0].val, 2);
t[0].subtab->column().val[0] = 3;
CHECK_EQUAL(t[0].subtab[0].val, 3);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 3);
CHECK_EQUAL(t[0].subtab->column().val[0], 3);
CHECK_EQUAL(t.column().subtab[0][0].val, 3);
t.column().subtab[0][0].val = 4;
CHECK_EQUAL(t[0].subtab[0].val, 4);
CHECK_EQUAL(t.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(t[0].subtab->column().val[0], 4);
CHECK_EQUAL(t.column().subtab[0][0].val, 4);
CHECK_EQUAL(ct[0].subtab[0].val, 4);
CHECK_EQUAL(ct.column().subtab[0]->column().val[0], 4);
CHECK_EQUAL(ct[0].subtab->column().val[0], 4);
CHECK_EQUAL(ct.column().subtab[0][0].val, 4);
t[0].subtab[0].subtab->add();
t[0].subtab[0].subtab[0].val = 5;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 5);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 5);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 5);
t.column().subtab[0]->column().subtab[0]->column().val[0] = 6;
CHECK_EQUAL(t[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(t.column().subtab[0]->column().subtab[0]->column().val[0], 6);
CHECK_EQUAL(ct[0].subtab[0].subtab[0].val, 6);
CHECK_EQUAL(ct.column().subtab[0]->column().subtab[0]->column().val[0], 6);
/*
Idea for compile time failure tests:
const MyTable2 t;
#if TEST_INDEX == 0
t[0].val = 7;
#elsif TEST_INDEX == 1
t.column().val[0] = 7;
#elsif TEST_INDEX == 2
t[0].subtab[0].val = 7;
#elsif TEST_INDEX == 3
t[0].subtab->column().val[0] = 7;
#endif
*/
}
TEST(Table_SubtableCopyOnSetAndInsert)
{
MyTable1 t1;
t1.add(7, 8);
MyTable2 t2;
t2.add(9, &t1);
MyTable1::Ref r1 = t2[0].subtab;
CHECK(t1 == *r1);
MyTable4 t4;
t4.add();
t4[0].mix.set_subtable(t2);
MyTable2::Ref r2 = unchecked_cast<MyTable2>(t4[0].mix.get_subtable());
CHECK(t2 == *r2);
}
TEST(Table_SetMethod)
{
MyTable1 t;
t.add(8, 9);
CHECK_EQUAL(t[0].val, 8);
CHECK_EQUAL(t[0].val2, 9);
t.set(0, 2, 4);
CHECK_EQUAL(t[0].val, 2);
CHECK_EQUAL(t[0].val2, 4);
}
namespace {
REALM_TABLE_2(TableDateAndBinary, date, OldDateTime, bin, Binary)
} // anonymous namespace
TEST(Table_DateAndBinary)
{
{
TableDateAndBinary t;
const size_t size = 10;
char data[size];
for (size_t i = 0; i < size; ++i)
data[i] = static_cast<char>(i);
t.add(8, BinaryData(data, size));
CHECK_EQUAL(t[0].date, 8);
CHECK_EQUAL(t[0].bin.size(), size);
CHECK(std::equal(t[0].bin.data(), t[0].bin.data() + size, data));
}
// Test that 64-bit dates are preserved
{
TableDateAndBinary t;
int64_t date = std::numeric_limits<int64_t>::max() - 400;
t.add(date, BinaryData(""));
CHECK_EQUAL(t[0].date.get().get_olddatetime(), date);
}
}
// Test for a specific bug found: Calling clear on a group with a table with a subtable
TEST(Table_ClearWithSubtableAndGroup)
{
Group group;
TableRef table = group.add_table("test");
DescriptorRef sub_1;
// Create specification with sub-table
table->add_column(type_String, "name");
table->add_column(type_Table, "sub", &sub_1);
sub_1->add_column(type_Int, "num");
CHECK_EQUAL(2, table->get_column_count());
// Add a row
table->insert_empty_row(0);
table->set_string(0, 0, "Foo");
CHECK_EQUAL(0, table->get_subtable_size(1, 0));
// Get the sub-table
{
TableRef subtable = table->get_subtable(1, 0);
CHECK(subtable->is_empty());
subtable->insert_empty_row(0);
subtable->set_int(0, 0, 123);
CHECK_EQUAL(123, subtable->get_int(0, 0));
}
CHECK_EQUAL(1, table->get_subtable_size(1, 0));
table->clear();
}
// set a subtable in an already exisitng row by providing an existing subtable as the example to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample2?
TEST(Table_SetSubTableByExample1)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add a row
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
// create a freestanding table to be used as a source by set_subtable
Table sub = Table();
sub.add_column(type_Int, "sub_first");
sub.add_column(type_String, "sub_second");
sub.add_empty_row();
sub.set_int(0, 0, 42);
sub.set_string(1, 0, "forty two");
sub.add_empty_row();
sub.set_int(0, 1, 3);
sub.set_string(1, 1, "PI");
// Get the sub-table back for inspection
{
TableRef subtable = table->get_subtable(2, 0);
CHECK(subtable->is_empty());
// add a subtable into the row, resembling the sub we just created
table->set_subtable(2, 0, &sub);
TableRef subtable2 = table->get_subtable(2, 0);
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1, 1));
}
}
// In the tableview class, set a subtable in an already exisitng row by providing an existing subtable as the example
// to copy
// FIXME: Do we need both this one and Table_SetSubTableByExample1?
TEST(Table_SetSubTableByExample2)
{
Group group;
TableRef table = group.add_table("test");
// Create specification with sub-table
table->add_column(type_Int, "first");
table->add_column(type_String, "second");
table->add_column(type_Table, "third");
// Create path to sub-table column
std::vector<size_t> column_path;
column_path.push_back(2); // third
table->add_subcolumn(column_path, type_Int, "sub_first");
table->add_subcolumn(column_path, type_String, "sub_second");
// Add two rows
table->insert_empty_row(0);
table->set_int(0, 0, 4);
table->set_string(1, 0, "Hello");
table->insert_empty_row(1);
table->set_int(0, 1, 8);
table->set_string(1, 1, "Hi!, Hello?");
Table sub = Table();
sub.add_column(type_Int, "sub_first");
sub.add_column(type_String, "sub_second");
sub.add_empty_row();
sub.set_int(0, 0, 42);
sub.set_string(1, 0, "forty two");
sub.add_empty_row();
sub.set_int(0, 1, 3);
sub.set_string(1, 1, "PI");
// create a tableview with the table as source
TableView view = table->find_all_int(0, 8); // select the second of the two rows
// Verify the sub table is empty
{
TableRef subtable = view.get_subtable(2, 0);
CHECK(subtable->is_empty());
// add a subtable into the second table row (first view row), resembling the sub we just created
view.set_subtable(2, 0, &sub);
TableRef subtable2 = view.get_subtable(2, 0); // fetch back the subtable from the view
CHECK_EQUAL(false, subtable->is_empty());
CHECK_EQUAL(42, subtable2->get_int(0, 0));
CHECK_EQUAL("forty two", subtable2->get_string(1, 0));
CHECK_EQUAL(3, subtable2->get_int(0, 1));
CHECK_EQUAL("PI", subtable2->get_string(1, 1));
TableRef subtable3 = table->get_subtable(2, 1); // fetch back the subtable from the table.
CHECK_EQUAL(42, subtable3->get_int(0, 0));
CHECK_EQUAL("forty two", subtable3->get_string(1, 0));
CHECK_EQUAL(3, subtable3->get_int(0, 1));
CHECK_EQUAL("PI", subtable3->get_string(1, 1));
}
}
TEST(Table_HasSharedSpec)
{
MyTable2 table1;
CHECK(!table1.has_shared_type());
Group g;
MyTable2::Ref table2 = g.add_table<MyTable2>("foo");
CHECK(!table2->has_shared_type());
table2->add();
CHECK(table2[0].subtab->has_shared_type());
// Subtable in mixed column
TestTableMX::Ref table3 = g.add_table<TestTableMX>("bar");
CHECK(!table3->has_shared_type());
table3->add();
table3[0].first.set_subtable<MyTable2>();
MyTable2::Ref table4 = table3[0].first.get_subtable<MyTable2>();
CHECK(table4);
CHECK(!table4->has_shared_type());
table4->add();
CHECK(!table4->has_shared_type());
CHECK(table4[0].subtab->has_shared_type());
}
namespace {
REALM_TABLE_3(TableAgg, c_int, Int, c_float, Float, c_double, Double)
// TODO: Bool? OldDateTime
} // anonymous namespace
#if TEST_DURATION > 0
#define TBL_SIZE REALM_MAX_BPNODE_SIZE * 10
#else
#define TBL_SIZE 10
#endif
TEST(Table_Aggregates)
{
TableAgg table;
int64_t i_sum = 0;
double f_sum = 0;
double d_sum = 0;
for (int i = 0; i < TBL_SIZE; i++) {
table.add(5987654, 4.0f, 3.0);
i_sum += 5987654;
f_sum += 4.0f;
d_sum += 3.0;
}
table.add(1, 1.1f, 1.2);
table.add(987654321, 11.0f, 12.0);
table.add(5, 4.0f, 3.0);
i_sum += 1 + 987654321 + 5;
f_sum += double(1.1f) + double(11.0f) + double(4.0f);
d_sum += 1.2 + 12.0 + 3.0;
double size = TBL_SIZE + 3;
double epsilon = std::numeric_limits<double>::epsilon();
// minimum
CHECK_EQUAL(1, table.column().c_int.minimum());
CHECK_EQUAL(1.1f, table.column().c_float.minimum());
CHECK_EQUAL(1.2, table.column().c_double.minimum());
// maximum
CHECK_EQUAL(987654321, table.column().c_int.maximum());
CHECK_EQUAL(11.0f, table.column().c_float.maximum());
CHECK_EQUAL(12.0, table.column().c_double.maximum());
// sum
CHECK_APPROXIMATELY_EQUAL(double(i_sum), double(table.column().c_int.sum()), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum, table.column().c_float.sum(), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum, table.column().c_double.sum(), 10 * epsilon);
// average
CHECK_APPROXIMATELY_EQUAL(i_sum / size, table.column().c_int.average(), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(f_sum / size, table.column().c_float.average(), 10 * epsilon);
CHECK_APPROXIMATELY_EQUAL(d_sum / size, table.column().c_double.average(), 10 * epsilon);
}
namespace {
REALM_TABLE_1(TableAgg2, c_count, Int)
} // anonymous namespace
TEST(Table_Aggregates2)
{
TableAgg2 table;
int c = -420;
int s = 0;
while (c < -20) {
table.add(c);
s += c;
c++;
}
CHECK_EQUAL(-420, table.column().c_count.minimum());
CHECK_EQUAL(-21, table.column().c_count.maximum());
CHECK_EQUAL(s, table.column().c_count.sum());
}
// Test Table methods max, min, avg, sum, on both nullable and non-nullable columns
TEST(Table_Aggregates3)
{
bool nullable = false;
for (int i = 0; i < 2; i++) {
// First we test everything with columns being nullable and with each column having at least 1 null
// Then we test everything with non-nullable columns where the null entries will instead be just
// 0, 0.0, etc.
nullable = (i == 1);
Group g;
TableRef table = g.add_table("Inventory");
table->insert_column(0, type_Int, "Price", nullable);
table->insert_column(1, type_Float, "Shipping", nullable);
table->insert_column(2, type_Double, "Rating", nullable);
table->insert_column(3, type_OldDateTime, "Delivery date", nullable);
table->insert_column(4, type_Timestamp, "Delivery date 2", nullable);
table->add_empty_row(3);
table->set_int(0, 0, 1);
// table->set_null(0, 1);
table->set_int(0, 2, 3);
// table->set_null(1, 0);
// table->set_null(1, 1);
table->set_float(1, 2, 30.f);
table->set_double(2, 0, 1.1);
table->set_double(2, 1, 2.2);
// table->set_null(2, 2);
table->set_olddatetime(3, 0, OldDateTime(2016, 2, 2));
// table->set_null(3, 1);
table->set_olddatetime(3, 2, OldDateTime(2016, 6, 6));
table->set_timestamp(4, 0, Timestamp(2, 2));
// table->set_null(4, 1);
table->set_timestamp(4, 2, Timestamp(6, 6));
size_t count;
size_t pos;
if (nullable) {
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0), 3);
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1), 30.f);
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2), 2.2);
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_olddatetime(3), OldDateTime(2016, 6, 6));
CHECK_EQUAL(table->maximum_olddatetime(3, &pos), OldDateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_timestamp(4), Timestamp(6, 6));
CHECK_EQUAL(table->maximum_timestamp(4, &pos), Timestamp(6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0), 1);
CHECK_EQUAL(table->minimum_int(0, &pos), 1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_float(1), 30.f);
CHECK_EQUAL(table->minimum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_double(2), 1.1);
CHECK_EQUAL(table->minimum_double(2, &pos), 1.1);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_olddatetime(3), OldDateTime(2016, 2, 2));
CHECK_EQUAL(table->minimum_olddatetime(3, &pos), OldDateTime(2016, 2, 2));
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_timestamp(4), Timestamp(2, 2));
CHECK_EQUAL(table->minimum_timestamp(4, &pos), Timestamp(2, 2));
CHECK_EQUAL(pos, 0);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0), (1 + 3) / 2., 0.01);
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3) / 2., 0.01);
CHECK_EQUAL(count, 2);
count = 123;
CHECK_EQUAL(table->average_float(1), 30.f);
CHECK_EQUAL(table->average_float(1, &count), 30.f);
CHECK_EQUAL(count, 1);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2), (1.1 + 2.2) / 2., 0.01);
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2) / 2., 0.01);
CHECK_EQUAL(count, 2);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
else { // not nullable
// max
pos = 123;
CHECK_EQUAL(table->maximum_int(0, &pos), 3);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_float(1, &pos), 30.f);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_double(2, &pos), 2.2);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->maximum_olddatetime(3, &pos), OldDateTime(2016, 6, 6));
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->maximum_timestamp(4, &pos), Timestamp(6, 6));
CHECK_EQUAL(pos, 2);
// min
pos = 123;
CHECK_EQUAL(table->minimum_int(0, &pos), 0);
CHECK_EQUAL(pos, 1);
pos = 123;
CHECK_EQUAL(table->minimum_float(1, &pos), 0.f);
CHECK_EQUAL(pos, 0);
pos = 123;
CHECK_EQUAL(table->minimum_double(2, &pos), 0.);
CHECK_EQUAL(pos, 2);
pos = 123;
CHECK_EQUAL(table->minimum_olddatetime(3, &pos), OldDateTime(0));
CHECK_EQUAL(pos, 1);
pos = 123;
// Timestamp(0, 0) is default value for non-nullable column
CHECK_EQUAL(table->minimum_timestamp(4, &pos), Timestamp(0, 0));
CHECK_EQUAL(pos, 1);
// average
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_int(0, &count), (1 + 3 + 0) / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_float(1, &count), 30.f / 3., 0.01);
CHECK_EQUAL(count, 3);
count = 123;
CHECK_APPROXIMATELY_EQUAL(table->average_double(2, &count), (1.1 + 2.2 + 0.) / 3., 0.01);
CHECK_EQUAL(count, 3);
// sum
CHECK_EQUAL(table->sum_int(0), 4);
CHECK_EQUAL(table->sum_float(1), 30.f);
CHECK_APPROXIMATELY_EQUAL(table->sum_double(2), 1.1 + 2.2, 0.01);
}
}
}
TEST(Table_EmptyMinmax)
{
Group g;
TableRef table = g.add_table("");
table->add_column(type_Timestamp, "");
size_t min_index;
Timestamp min_ts = table->minimum_timestamp(0, &min_index);
CHECK_EQUAL(min_index, realm::npos);
CHECK(min_ts.is_null());
size_t max_index;
Timestamp max_ts = table->maximum_timestamp(0, &max_index);
CHECK_EQUAL(max_index, realm::npos);
CHECK(max_ts.is_null());
}
TEST(Table_LanguageBindings)
{
Table* table = LangBindHelper::new_table();
CHECK(table->is_attached());
table->add_column(type_Int, "i");
table->insert_empty_row(0);
table->set_int(0, 0, 10);
table->insert_empty_row(1);
table->set_int(0, 1, 12);
Table* table2 = LangBindHelper::copy_table(*table);
CHECK(table2->is_attached());
CHECK(*table == *table2);
LangBindHelper::unbind_table_ptr(table);
LangBindHelper::unbind_table_ptr(table2);
}
TEST(Table_MultipleColumn)
{
Table table;
table.add_column(type_Int, "first");
table.add_column(type_Int, "first");
CHECK_EQUAL(table.get_column_count(), 2);
CHECK_EQUAL(table.get_column_index("first"), 0);
}
TEST(Table_FormerLeakCase)
{
Table sub;
sub.add_column(type_Int, "a");
Table root;
DescriptorRef subdesc;
root.add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "a");
root.add_empty_row(1);
root.set_subtable(0, 0, &sub);
root.set_subtable(0, 0, nullptr);
}
namespace {
REALM_TABLE_3(TablePivotAgg, sex, String, age, Int, hired, Bool)
} // anonymous namespace
TEST(Table_Pivot)
{
size_t count = 1717;
TablePivotAgg table;
int64_t age_sum[2] = {0, 0};
int64_t age_cnt[2] = {0, 0};
int64_t age_min[2];
int64_t age_max[2];
double age_avg[2];
for (size_t i = 0; i < count; ++i) {
size_t sex = i % 2;
int64_t age = 3 + (i % 117);
table.add((sex == 0) ? "Male" : "Female", age, true);
age_sum[sex] += age;
age_cnt[sex] += 1;
if ((i < 2) || age < age_min[sex])
age_min[sex] = age;
if ((i < 2) || age > age_max[sex])
age_max[sex] = age;
}
for (size_t sex = 0; sex < 2; ++sex) {
age_avg[sex] = double(age_sum[sex]) / double(age_cnt[sex]);
}
for (int i = 0; i < 2; ++i) {
Table result_count;
table.aggregate(0, 1, Table::aggr_count, result_count);
CHECK_EQUAL(2, result_count.get_column_count());
CHECK_EQUAL(2, result_count.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_cnt[sex], result_count.get_int(1, sex));
}
Table result_sum;
table.aggregate(0, 1, Table::aggr_sum, result_sum);
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_sum[sex], result_sum.get_int(1, sex));
}
Table result_avg;
table.aggregate(0, 1, Table::aggr_avg, result_avg);
if ((false)) {
std::ostringstream ss;
result_avg.to_string(ss);
std::cerr << "\nMax:\n" << ss.str();
}
CHECK_EQUAL(2, result_avg.get_column_count());
CHECK_EQUAL(2, result_avg.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_avg[sex], result_avg.get_double(1, sex));
}
Table result_min;
table.aggregate(0, 1, Table::aggr_min, result_min);
CHECK_EQUAL(2, result_min.get_column_count());
CHECK_EQUAL(2, result_min.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_min[sex], result_min.get_int(1, sex));
}
Table result_max;
table.aggregate(0, 1, Table::aggr_max, result_max);
CHECK_EQUAL(2, result_max.get_column_count());
CHECK_EQUAL(2, result_max.size());
for (size_t sex = 0; sex < 2; ++sex) {
CHECK_EQUAL(age_max[sex], result_max.get_int(1, sex));
}
// Test with enumerated strings in second loop
table.optimize();
}
}
namespace {
void compare_table_with_slice(TestContext& test_context, const Table& table, const Table& slice, size_t offset,
size_t size)
{
ConstDescriptorRef table_desc = table.get_descriptor();
ConstDescriptorRef slice_desc = slice.get_descriptor();
CHECK(*table_desc == *slice_desc);
if (*table_desc != *slice_desc)
return;
size_t num_cols = table.get_column_count();
for (size_t col_i = 0; col_i != num_cols; ++col_i) {
DataType type = table.get_column_type(col_i);
switch (type) {
case type_Int:
case type_Link:
for (size_t i = 0; i != size; ++i) {
int_fast64_t v_1 = table.get_int(col_i, offset + i);
int_fast64_t v_2 = slice.get_int(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Bool:
for (size_t i = 0; i != size; ++i) {
bool v_1 = table.get_bool(col_i, offset + i);
bool v_2 = slice.get_bool(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Float:
for (size_t i = 0; i != size; ++i) {
float v_1 = table.get_float(col_i, offset + i);
float v_2 = slice.get_float(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Double:
for (size_t i = 0; i != size; ++i) {
double v_1 = table.get_double(col_i, offset + i);
double v_2 = slice.get_double(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_String:
for (size_t i = 0; i != size; ++i) {
StringData v_1 = table.get_string(col_i, offset + i);
StringData v_2 = slice.get_string(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Binary:
for (size_t i = 0; i != size; ++i) {
BinaryData v_1 = table.get_binary(col_i, offset + i);
BinaryData v_2 = slice.get_binary(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_OldDateTime:
for (size_t i = 0; i != size; ++i) {
OldDateTime v_1 = table.get_olddatetime(col_i, offset + i);
OldDateTime v_2 = slice.get_olddatetime(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Timestamp:
for (size_t i = 0; i != size; ++i) {
Timestamp v_1 = table.get_timestamp(col_i, offset + i);
Timestamp v_2 = slice.get_timestamp(col_i, i);
CHECK_EQUAL(v_1, v_2);
}
break;
case type_Table:
for (size_t i = 0; i != size; ++i) {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
}
break;
case type_Mixed:
for (size_t i = 0; i != size; ++i) {
Mixed v_1 = table.get_mixed(col_i, offset + i);
Mixed v_2 = slice.get_mixed(col_i, i);
CHECK_EQUAL(v_1.get_type(), v_2.get_type());
if (v_1.get_type() == v_2.get_type()) {
switch (v_1.get_type()) {
case type_Int:
CHECK_EQUAL(v_1.get_int(), v_2.get_int());
break;
case type_Bool:
CHECK_EQUAL(v_1.get_bool(), v_2.get_bool());
break;
case type_Float:
CHECK_EQUAL(v_1.get_float(), v_2.get_float());
break;
case type_Double:
CHECK_EQUAL(v_1.get_double(), v_2.get_double());
break;
case type_String:
CHECK_EQUAL(v_1.get_string(), v_2.get_string());
break;
case type_Binary:
CHECK_EQUAL(v_1.get_binary(), v_2.get_binary());
break;
case type_OldDateTime:
CHECK_EQUAL(v_1.get_olddatetime(), v_2.get_olddatetime());
break;
case type_Timestamp:
CHECK_EQUAL(v_1.get_timestamp(), v_2.get_timestamp());
break;
case type_Table: {
ConstTableRef t_1 = table.get_subtable(col_i, offset + i);
ConstTableRef t_2 = slice.get_subtable(col_i, i);
CHECK(*t_1 == *t_2);
break;
}
case type_Mixed:
case type_Link:
case type_LinkList:
REALM_ASSERT(false);
}
}
}
break;
case type_LinkList:
break;
}
}
}
void test_write_slice_name(TestContext& test_context, const Table& table, StringData expect_name, bool override_name)
{
size_t offset = 0, size = 0;
std::ostringstream out;
if (override_name) {
table.write(out, offset, size, expect_name);
}
else {
table.write(out, offset, size);
}
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table(expect_name);
CHECK(slice);
}
void test_write_slice_contents(TestContext& test_context, const Table& table, size_t offset, size_t size)
{
std::ostringstream out;
table.write(out, offset, size);
std::string str = out.str();
BinaryData buffer(str.data(), str.size());
bool take_ownership = false;
Group group(buffer, take_ownership);
TableRef slice = group.get_table("test");
CHECK(slice);
if (slice) {
size_t remaining_size = table.size() - offset;
size_t size_2 = size;
if (size_2 > remaining_size)
size_2 = remaining_size;
CHECK_EQUAL(size_2, slice->size());
if (size_2 == slice->size())
compare_table_with_slice(test_context, table, *slice, offset, size_2);
}
}
} // anonymous namespace
TEST(Table_WriteSlice)
{
// check that the name of the written table is as expected
{
Table table;
test_write_slice_name(test_context, table, "", false);
test_write_slice_name(test_context, table, "foo", true); // Override
test_write_slice_name(test_context, table, "", true); // Override
}
{
Group group;
TableRef table = group.add_table("test");
test_write_slice_name(test_context, *table, "test", false);
test_write_slice_name(test_context, *table, "foo", true); // Override
test_write_slice_name(test_context, *table, "", true); // Override
}
// Run through a 3-D matrix of table sizes, slice offsets, and
// slice sizes. Each test involves a table with columns of each
// possible type.
#if TEST_DURATION > 0
int table_sizes[] = {0, 1, 2, 3, 5, 9, 27, 81, 82, 243, 729, 2187, 6561};
#else
int table_sizes[] = {0, 1, 2, 3, 5, 9, 27, 81, 82, 243, 729, 2187};
#endif
int num_sizes = sizeof table_sizes / sizeof *table_sizes;
for (int table_size_i = 0; table_size_i != num_sizes; ++table_size_i) {
int table_size = table_sizes[table_size_i];
Group group;
TableRef table = group.add_table("test");
bool fixed_subtab_sizes = true;
setup_multi_table(*table, table_size, 1, fixed_subtab_sizes);
for (int offset_i = 0; offset_i != num_sizes; ++offset_i) {
int offset = table_sizes[offset_i];
if (offset > table_size)
break;
for (int size_i = 0; size_i != num_sizes; ++size_i) {
int size = table_sizes[size_i];
// This also checks that the range can extend beyond
// end of table
test_write_slice_contents(test_context, *table, offset, size);
if (offset + size > table_size)
break;
}
}
}
}
TEST(Table_Parent)
{
TableRef table = Table::create();
CHECK_EQUAL(TableRef(), table->get_parent_table());
CHECK_EQUAL(realm::npos, table->get_parent_row_index()); // Not a subtable
CHECK_EQUAL(realm::npos, table->get_index_in_group()); // Not a group-level table
DescriptorRef subdesc;
table->add_column(type_Table, "", &subdesc);
table->add_column(type_Mixed, "");
subdesc->add_column(type_Int, "");
table->add_empty_row(2);
table->set_mixed(1, 0, Mixed::subtable_tag());
table->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab;
size_t column_ndx = 0;
subtab = table->get_subtable(0, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after new
// column is insert.
table->insert_column(0, type_Int, "");
subtab = table->get_subtable(1, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(2, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(2, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(2, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
// Check that column indexes are properly adjusted after inserted
// column is removed.
table->remove_column(0);
subtab = table->get_subtable(0, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(0, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(0, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 0);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(0, subtab->get_parent_row_index());
subtab = table->get_subtable(1, 1);
CHECK_EQUAL(table, subtab->get_parent_table(&column_ndx));
CHECK_EQUAL(1, column_ndx);
CHECK_EQUAL(1, subtab->get_parent_row_index());
}
TEST(Table_RegularSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
DescriptorRef subdesc;
parent->add_column(type_Table, "a", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
TableRef subtab_0_0 = parent->get_subtable(0, 0);
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
parent->add_column(type_Table, "b", &subdesc);
subdesc->add_column(type_Int, "x");
parent->add_empty_row();
subtab_0_0->add_empty_row();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
TableRef subtab_0_1 = parent->get_subtable(0, 1);
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
TableRef subtab_1_0 = parent->get_subtable(1, 0);
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
TableRef subtab_1_1 = parent->get_subtable(1, 1);
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Float, "f");
subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int(0, 0, 10000);
subtab_0_0->set_float(1, 0, 10010.0f);
subtab_1_1->set_int(0, 0, 11100);
subtab_1_1->set_double(1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11100, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double(1, 0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int(0, 0, 10001);
subtab_0_0->set_float(1, 0, 10011.0f);
subtab_1_1->set_int(0, 0, 11101);
subtab_1_1->set_double(1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11101, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
subtab_0_0->set_int(0, 0, 10002);
subtab_0_0->set_float(1, 0, 10012.0f);
subtab_1_1->set_int(0, 0, 11102);
subtab_1_1->set_double(1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11102, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int(0, 0, 10003);
subtab_0_0->set_float(1, 0, 10013.0f);
subtab_1_1->set_int(0, 0, 11103);
subtab_1_1->set_double(1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11103, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10004);
subtab_0_0->set_float(1, 0, 10014.0f);
subtab_1_1->set_int(0, 0, 11104);
subtab_1_1->set_double(1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11104, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int(0, 0, 10005);
subtab_0_0->set_float(1, 0, 10015.0f);
subtab_1_1->set_int(0, 0, 11105);
subtab_1_1->set_double(1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11105, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10006);
subtab_0_0->set_float(1, 0, 10016.0f);
subtab_1_1->set_int(0, 0, 11106);
subtab_1_1->set_double(1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Table, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11106, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int(0, 0, 10007);
subtab_0_0->set_float(1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
parent->remove_column(1);
subtab_0_0->set_int(0, 0, 10008);
subtab_0_0->set_float(1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
// Clear subtable
parent->clear_subtable(0, 0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Table, "c", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0, 0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Table, "d", &subdesc);
subdesc->add_column(type_String, "x");
parent->add_empty_row(2);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0, 0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0, 0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_MixedSubtablesRetain)
{
// Create one degenerate subtable
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_column(type_Int, "x");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(1, parent->size());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(0, subtab_0_0->size());
// Expand to 4 subtables in a 2-by-2 parent.
subtab_0_0->add_empty_row();
parent->add_column(type_Mixed, "b");
parent->set_mixed(1, 0, Mixed::subtable_tag());
TableRef subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_0->add_column(type_Int, "x");
parent->add_empty_row();
parent->set_mixed(0, 1, Mixed::subtable_tag());
TableRef subtab_0_1 = parent->get_subtable(0, 1);
subtab_0_1->add_column(type_Int, "x");
parent->set_mixed(1, 1, Mixed::subtable_tag());
TableRef subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_column(type_Int, "x");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(1, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(1, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(0, subtab_1_1->size());
// Check that subtables get their specs correctly updated
subtab_0_0->add_column(type_Float, "f");
subtab_0_1->add_column(type_Float, "f");
subtab_1_0->add_column(type_Double, "d");
subtab_1_1->add_column(type_Double, "d");
CHECK_EQUAL(2, subtab_0_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_0->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_0->get_column_type(1));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL("f", subtab_0_0->get_column_name(1));
CHECK_EQUAL(2, subtab_0_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_0_1->get_column_type(0));
CHECK_EQUAL(type_Float, subtab_0_1->get_column_type(1));
CHECK_EQUAL("x", subtab_0_1->get_column_name(0));
CHECK_EQUAL("f", subtab_0_1->get_column_name(1));
CHECK_EQUAL(2, subtab_1_0->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_0->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_0->get_column_type(1));
CHECK_EQUAL("x", subtab_1_0->get_column_name(0));
CHECK_EQUAL("d", subtab_1_0->get_column_name(1));
CHECK_EQUAL(2, subtab_1_1->get_column_count());
CHECK_EQUAL(type_Int, subtab_1_1->get_column_type(0));
CHECK_EQUAL(type_Double, subtab_1_1->get_column_type(1));
CHECK_EQUAL("x", subtab_1_1->get_column_name(0));
CHECK_EQUAL("d", subtab_1_1->get_column_name(1));
// Check that cell changes in subtables are visible
subtab_1_1->add_empty_row();
subtab_0_0->set_int(0, 0, 10000);
subtab_0_0->set_float(1, 0, 10010.0f);
subtab_1_1->set_int(0, 0, 11100);
subtab_1_1->set_double(1, 0, 11110.0);
parent->add_empty_row();
CHECK_EQUAL(3, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10000, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10010.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11100, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11110.0, subtab_1_1->get_double(1, 0));
// Insert a row and a column before all the subtables
parent->insert_column(0, type_Table, "dummy_1");
parent->insert_empty_row(0);
subtab_0_0->set_int(0, 0, 10001);
subtab_0_0->set_float(1, 0, 10011.0f);
subtab_1_1->set_int(0, 0, 11101);
subtab_1_1->set_double(1, 0, 11111.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(4, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10001, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10011.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11101, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11111.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Insert a row and a column between the subtables
parent->insert_column(2, type_Int, "dummy_2");
parent->insert_empty_row(2);
parent->set_mixed(3, 2, "Lopadotemachoselachogaleokranioleipsanodrimhypotrimmatosilphio"
"paraomelitokatakechymenokichlepikossyphophattoperisteralektryonopte"
"kephalliokigklopeleiolagoiosiraiobaphetraganopterygon");
subtab_0_0->set_int(0, 0, 10002);
subtab_0_0->set_float(1, 0, 10012.0f);
subtab_1_1->set_int(0, 0, 11102);
subtab_1_1->set_double(1, 0, 11112.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10002, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10012.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11102, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11112.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Insert a column after the subtables
parent->insert_column(4, type_Table, "dummy_3");
subtab_0_0->set_int(0, 0, 10003);
subtab_0_0->set_float(1, 0, 10013.0f);
subtab_1_1->set_int(0, 0, 11103);
subtab_1_1->set_double(1, 0, 11113.0);
CHECK_EQUAL(5, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Int, parent->get_column_type(2));
CHECK_EQUAL(type_Mixed, parent->get_column_type(3));
CHECK_EQUAL(type_Table, parent->get_column_type(4));
CHECK_EQUAL(5, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10003, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10013.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11103, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11113.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 3));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(3, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(3, 3));
// Remove the row and the column between the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10004);
subtab_0_0->set_float(1, 0, 10014.0f);
subtab_1_1->set_int(0, 0, 11104);
subtab_1_1->set_double(1, 0, 11114.0);
CHECK_EQUAL(4, parent->get_column_count());
CHECK_EQUAL(type_Table, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Mixed, parent->get_column_type(2));
CHECK_EQUAL(type_Table, parent->get_column_type(3));
CHECK_EQUAL(4, parent->size());
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL(10004, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10014.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11104, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11114.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(1, 1));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(1, 2));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(2, 1));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(2, 2));
// Remove the row and the column before the subtables
parent->remove_column(0);
parent->remove(0);
subtab_0_0->set_int(0, 0, 10005);
subtab_0_0->set_float(1, 0, 10015.0f);
subtab_1_1->set_int(0, 0, 11105);
subtab_1_1->set_double(1, 0, 11115.0);
CHECK_EQUAL(3, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(type_Table, parent->get_column_type(2));
CHECK_EQUAL(3, parent->size());
CHECK_EQUAL(10005, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10015.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11105, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11115.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Remove the row and the column after the subtables
parent->remove_column(2);
parent->remove(2);
subtab_0_0->set_int(0, 0, 10006);
subtab_0_0->set_float(1, 0, 10016.0f);
subtab_1_1->set_int(0, 0, 11106);
subtab_1_1->set_double(1, 0, 11116.0);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL(type_Mixed, parent->get_column_type(1));
CHECK_EQUAL(2, parent->size());
CHECK_EQUAL(10006, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10016.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(11106, subtab_1_1->get_int(0, 0));
CHECK_EQUAL(11116.0, subtab_1_1->get_double(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_0_1, parent->get_subtable(0, 1));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
CHECK_EQUAL(subtab_1_1, parent->get_subtable(1, 1));
// Check that subtable accessors are detached when the subtables are removed
parent->remove(1);
subtab_0_0->set_int(0, 0, 10007);
subtab_0_0->set_float(1, 0, 10017.0f);
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10007, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10017.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
CHECK_EQUAL(subtab_1_0, parent->get_subtable(1, 0));
parent->remove_column(1);
subtab_0_0->set_int(0, 0, 10008);
subtab_0_0->set_float(1, 0, 10018.0f);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
CHECK_EQUAL(10008, subtab_0_0->get_int(0, 0));
CHECK_EQUAL(10018.0f, subtab_0_0->get_float(1, 0));
CHECK_EQUAL(subtab_0_0, parent->get_subtable(0, 0));
// Remove subtable
parent->clear_subtable(0, 0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
CHECK(!subtab_0_0->is_attached());
// Clear parent table
parent->clear();
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 4 new subtables, then remove some of them in a different way
parent->add_column(type_Mixed, "c");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
CHECK(subtab_0_0);
CHECK(subtab_0_1);
CHECK(subtab_1_0);
CHECK(subtab_1_1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "pneumonoultramicroscopicsilicovolcanoconiosis");
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(2, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK(subtab_0_1->is_attached());
CHECK(subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(0, subtab_0_0->size());
CHECK_EQUAL(0, subtab_0_1->size());
CHECK_EQUAL(0, subtab_1_0->size());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
parent->remove(0);
parent->remove_column(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(1, parent->size());
subtab_1_1 = parent->get_subtable(0, 0);
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(subtab_1_1->is_attached());
CHECK_EQUAL(1, subtab_1_1->size());
CHECK_EQUAL("pneumonoultramicroscopicsilicovolcanoconiosis", subtab_1_1->get_string(0, 0));
// Insert 2x2 new subtables, then remove them all together
parent->add_column(type_Mixed, "d");
parent->add_empty_row(2);
parent->set_mixed(0, 0, Mixed::subtable_tag());
parent->set_mixed(0, 1, Mixed::subtable_tag());
parent->set_mixed(1, 0, Mixed::subtable_tag());
parent->set_mixed(1, 1, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_1 = parent->get_subtable(0, 1);
subtab_1_0 = parent->get_subtable(1, 0);
subtab_1_1 = parent->get_subtable(1, 1);
subtab_1_1->add_column(type_String, "x");
subtab_1_1->add_empty_row();
subtab_1_1->set_string(0, 0, "supercalifragilisticexpialidocious");
parent->clear();
CHECK_EQUAL(2, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
CHECK(!subtab_0_1->is_attached());
CHECK(!subtab_1_0->is_attached());
CHECK(!subtab_1_1->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last row
parent->add_empty_row(1);
parent->remove_column(0);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "brahmaputra");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("brahmaputra", subtab_0_0->get_string(0, 0));
parent->remove(0);
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
// Insert 1x1 new subtable, then remove it by removing the last column
parent->add_empty_row(1);
parent->set_mixed(0, 0, Mixed::subtable_tag());
subtab_0_0 = parent->get_subtable(0, 0);
subtab_0_0->add_column(type_String, "x");
subtab_0_0->add_empty_row(1);
subtab_0_0->set_string(0, 0, "baikonur");
CHECK_EQUAL(1, parent->get_column_count());
CHECK_EQUAL(type_Mixed, parent->get_column_type(0));
CHECK_EQUAL("d", parent->get_column_name(0));
CHECK_EQUAL(1, parent->size());
CHECK(subtab_0_0->is_attached());
CHECK_EQUAL(1, subtab_0_0->get_column_count());
CHECK_EQUAL(type_String, subtab_0_0->get_column_type(0));
CHECK_EQUAL("x", subtab_0_0->get_column_name(0));
CHECK_EQUAL(1, subtab_0_0->size());
CHECK_EQUAL("baikonur", subtab_0_0->get_string(0, 0));
parent->remove_column(0);
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!subtab_0_0->is_attached());
}
TEST(Table_RowAccessor)
{
Table table;
DescriptorRef subdesc;
table.add_column(type_Int, "int");
table.add_column(type_Bool, "bool");
table.add_column(type_Float, "");
table.add_column(type_Double, "");
table.add_column(type_String, "");
table.add_column(type_Binary, "", true);
table.add_column(type_OldDateTime, "");
table.add_column(type_Table, "", &subdesc);
table.add_column(type_Mixed, "");
subdesc->add_column(type_Int, "i");
table.add_empty_row(2);
BinaryData bin("bin", 3);
Table empty_subtab;
empty_subtab.add_column(type_Int, "i");
Table one_subtab;
one_subtab.add_column(type_Int, "i");
one_subtab.add_empty_row(1);
one_subtab.set_int(0, 0, 19);
Table two_subtab;
two_subtab.add_column(type_Int, "i");
two_subtab.add_empty_row(1);
two_subtab.set_int(0, 0, 29);
table.set_int(0, 1, 4923);
table.set_bool(1, 1, true);
table.set_float(2, 1, 5298.0f);
table.set_double(3, 1, 2169.0);
table.set_string(4, 1, "str");
table.set_binary(5, 1, bin);
table.set_olddatetime(6, 1, 7739);
table.set_subtable(7, 1, &one_subtab);
table.set_mixed(8, 1, Mixed("mix"));
// Check getters for `RowExpr`
{
CHECK_EQUAL(9, table[0].get_column_count());
CHECK_EQUAL(type_Int, table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, table[0].get_column_type(1));
CHECK_EQUAL("int", table[0].get_column_name(0));
CHECK_EQUAL("bool", table[0].get_column_name(1));
CHECK_EQUAL(0, table[0].get_column_index("int"));
CHECK_EQUAL(1, table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), table[0].get_int(0));
CHECK_EQUAL(bool(), table[0].get_bool(1));
CHECK_EQUAL(float(), table[0].get_float(2));
CHECK_EQUAL(double(), table[0].get_double(3));
CHECK_EQUAL(StringData(""), table[0].get_string(4));
CHECK_EQUAL(BinaryData(), table[0].get_binary(5));
CHECK_EQUAL(OldDateTime(), table[0].get_olddatetime(6));
CHECK_EQUAL(0, table[0].get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), table[0].get_mixed(8));
CHECK_EQUAL(type_Int, table[0].get_mixed_type(8));
CHECK_EQUAL(4923, table[1].get_int(0));
CHECK_EQUAL(true, table[1].get_bool(1));
CHECK_EQUAL(5298.0f, table[1].get_float(2));
CHECK_EQUAL(2169.0, table[1].get_double(3));
CHECK_EQUAL("str", table[1].get_string(4));
CHECK_EQUAL(bin, table[1].get_binary(5));
CHECK_EQUAL(OldDateTime(7739), table[1].get_olddatetime(6));
CHECK_EQUAL(1, table[1].get_subtable_size(7));
CHECK_EQUAL("mix", table[1].get_mixed(8));
CHECK_EQUAL(type_String, table[1].get_mixed_type(8));
TableRef subtab_0 = table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRowExpr`
{
const Table& const_table = table;
CHECK_EQUAL(9, const_table[0].get_column_count());
CHECK_EQUAL(type_Int, const_table[0].get_column_type(0));
CHECK_EQUAL(type_Bool, const_table[0].get_column_type(1));
CHECK_EQUAL("int", const_table[0].get_column_name(0));
CHECK_EQUAL("bool", const_table[0].get_column_name(1));
CHECK_EQUAL(0, const_table[0].get_column_index("int"));
CHECK_EQUAL(1, const_table[0].get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_int(0));
CHECK_EQUAL(bool(), const_table[0].get_bool(1));
CHECK_EQUAL(float(), const_table[0].get_float(2));
CHECK_EQUAL(double(), const_table[0].get_double(3));
CHECK_EQUAL(StringData(""), const_table[0].get_string(4));
CHECK_EQUAL(BinaryData(), const_table[0].get_binary(5));
CHECK_EQUAL(OldDateTime(), const_table[0].get_olddatetime(6));
CHECK_EQUAL(0, const_table[0].get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), const_table[0].get_mixed(8));
CHECK_EQUAL(type_Int, const_table[0].get_mixed_type(8));
CHECK_EQUAL(4923, const_table[1].get_int(0));
CHECK_EQUAL(true, const_table[1].get_bool(1));
CHECK_EQUAL(5298.0f, const_table[1].get_float(2));
CHECK_EQUAL(2169.0, const_table[1].get_double(3));
CHECK_EQUAL("str", const_table[1].get_string(4));
CHECK_EQUAL(bin, const_table[1].get_binary(5));
CHECK_EQUAL(OldDateTime(7739), const_table[1].get_olddatetime(6));
CHECK_EQUAL(1, const_table[1].get_subtable_size(7));
CHECK_EQUAL("mix", const_table[1].get_mixed(8));
CHECK_EQUAL(type_String, const_table[1].get_mixed_type(8));
ConstTableRef subtab_0 = const_table[0].get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = const_table[1].get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(9, row_0.get_column_count());
CHECK_EQUAL(type_Int, row_0.get_column_type(0));
CHECK_EQUAL(type_Bool, row_0.get_column_type(1));
CHECK_EQUAL("int", row_0.get_column_name(0));
CHECK_EQUAL("bool", row_0.get_column_name(1));
CHECK_EQUAL(0, row_0.get_column_index("int"));
CHECK_EQUAL(1, row_0.get_column_index("bool"));
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
TableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const Row`
{
const Row row_0 = table[0];
const Row row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `ConstRow`
{
ConstRow row_0 = table[0];
ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check getters for `const ConstRow` (double constness)
{
const ConstRow row_0 = table[0];
const ConstRow row_1 = table[1];
CHECK_EQUAL(int_fast64_t(), row_0.get_int(0));
CHECK_EQUAL(bool(), row_0.get_bool(1));
CHECK_EQUAL(float(), row_0.get_float(2));
CHECK_EQUAL(double(), row_0.get_double(3));
CHECK_EQUAL(StringData(""), row_0.get_string(4));
CHECK_EQUAL(BinaryData(), row_0.get_binary(5));
CHECK_EQUAL(OldDateTime(), row_0.get_olddatetime(6));
CHECK_EQUAL(0, row_0.get_subtable_size(7));
CHECK_EQUAL(int_fast64_t(), row_0.get_mixed(8));
CHECK_EQUAL(type_Int, row_0.get_mixed_type(8));
CHECK_EQUAL(4923, row_1.get_int(0));
CHECK_EQUAL(true, row_1.get_bool(1));
CHECK_EQUAL(5298.0f, row_1.get_float(2));
CHECK_EQUAL(2169.0, row_1.get_double(3));
CHECK_EQUAL("str", row_1.get_string(4));
CHECK_EQUAL(bin, row_1.get_binary(5));
CHECK_EQUAL(OldDateTime(7739), row_1.get_olddatetime(6));
CHECK_EQUAL(1, row_1.get_subtable_size(7));
CHECK_EQUAL("mix", row_1.get_mixed(8));
CHECK_EQUAL(type_String, row_1.get_mixed_type(8));
ConstTableRef subtab_0 = row_0.get_subtable(7);
CHECK(*subtab_0 == empty_subtab);
ConstTableRef subtab_1 = row_1.get_subtable(7);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
}
// Check setters for `Row`
{
Row row_0 = table[0];
Row row_1 = table[1];
row_0.set_int(0, 5651);
row_0.set_bool(1, true);
row_0.set_float(2, 8397.0f);
row_0.set_double(3, 1937.0);
row_0.set_string(4, "foo");
row_0.set_binary(5, bin);
row_0.set_olddatetime(6, OldDateTime(9992));
row_0.set_subtable(7, &one_subtab);
row_0.set_mixed(8, Mixed(3637.0f));
row_1.set_int(0, int_fast64_t());
row_1.set_bool(1, bool());
row_1.set_float(2, float());
row_1.set_double(3, double());
row_1.set_string(4, StringData(""));
row_1.set_binary(5, BinaryData());
row_1.set_olddatetime(6, OldDateTime());
row_1.set_subtable(7, nullptr);
row_1.set_mixed(8, Mixed());
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(5651, table.get_int(0, 0));
CHECK_EQUAL(true, table.get_bool(1, 0));
CHECK_EQUAL(8397.0f, table.get_float(2, 0));
CHECK_EQUAL(1937.0, table.get_double(3, 0));
CHECK_EQUAL("foo", table.get_string(4, 0));
CHECK_EQUAL(bin, table.get_binary(5, 0));
CHECK_EQUAL(OldDateTime(9992), table.get_olddatetime(6, 0));
CHECK_EQUAL(3637.0f, table.get_mixed(8, 0));
CHECK_EQUAL(int_fast64_t(), table.get_int(0, 1));
CHECK_EQUAL(bool(), table.get_bool(1, 1));
CHECK_EQUAL(float(), table.get_float(2, 1));
CHECK_EQUAL(double(), table.get_double(3, 1));
CHECK_EQUAL(StringData(""), table.get_string(4, 1));
CHECK_EQUAL(BinaryData(), table.get_binary(5, 1));
CHECK_EQUAL(OldDateTime(), table.get_olddatetime(6, 1));
CHECK_EQUAL(int_fast64_t(), table.get_mixed(8, 1));
TableRef subtab_0 = table.get_subtable(7, 0);
CHECK_EQUAL(19, subtab_0->get_int(0, 0));
CHECK(*subtab_0 == one_subtab);
TableRef subtab_1 = table.get_subtable(7, 1);
CHECK(*subtab_1 == empty_subtab);
row_0.set_mixed_subtable(8, 0);
row_1.set_mixed_subtable(8, &two_subtab);
subtab_0 = table.get_subtable(8, 0);
subtab_1 = table.get_subtable(8, 1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK(*subtab_0 == Table());
CHECK_EQUAL(29, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == two_subtab);
}
// Check setters for `RowExpr`
{
table[0].set_int(0, int_fast64_t());
table[0].set_bool(1, bool());
table[0].set_float(2, float());
table[0].set_double(3, double());
table[0].set_string(4, StringData(""));
table[0].set_binary(5, BinaryData());
table[0].set_olddatetime(6, OldDateTime());
table[0].set_subtable(7, nullptr);
table[0].set_mixed(8, Mixed());
table[1].set_int(0, 5651);
table[1].set_bool(1, true);
table[1].set_float(2, 8397.0f);
table[1].set_double(3, 1937.0);
table[1].set_string(4, "foo");
table[1].set_binary(5, bin);
table[1].set_olddatetime(6, OldDateTime(9992));
table[1].set_subtable(7, &one_subtab);
table[1].set_mixed(8, Mixed(3637.0f));
Mixed mix_subtab((Mixed::subtable_tag()));
CHECK_EQUAL(int_fast64_t(), table.get_int(0, 0));
CHECK_EQUAL(bool(), table.get_bool(1, 0));
CHECK_EQUAL(float(), table.get_float(2, 0));
CHECK_EQUAL(double(), table.get_double(3, 0));
CHECK_EQUAL(StringData(""), table.get_string(4, 0));
CHECK_EQUAL(BinaryData(), table.get_binary(5, 0));
CHECK_EQUAL(OldDateTime(), table.get_olddatetime(6, 0));
CHECK_EQUAL(int_fast64_t(), table.get_mixed(8, 0));
CHECK_EQUAL(5651, table.get_int(0, 1));
CHECK_EQUAL(true, table.get_bool(1, 1));
CHECK_EQUAL(8397.0f, table.get_float(2, 1));
CHECK_EQUAL(1937.0, table.get_double(3, 1));
CHECK_EQUAL("foo", table.get_string(4, 1));
CHECK_EQUAL(bin, table.get_binary(5, 1));
CHECK_EQUAL(OldDateTime(9992), table.get_olddatetime(6, 1));
CHECK_EQUAL(3637.0f, table.get_mixed(8, 1));
TableRef subtab_0 = table.get_subtable(7, 0);
CHECK(*subtab_0 == empty_subtab);
TableRef subtab_1 = table.get_subtable(7, 1);
CHECK_EQUAL(19, subtab_1->get_int(0, 0));
CHECK(*subtab_1 == one_subtab);
table[0].set_mixed_subtable(8, &two_subtab);
table[1].set_mixed_subtable(8, 0);
subtab_0 = table.get_subtable(8, 0);
subtab_1 = table.get_subtable(8, 1);
CHECK(subtab_0);
CHECK(subtab_1);
CHECK(subtab_0->is_attached());
CHECK(subtab_1->is_attached());
CHECK_EQUAL(29, subtab_0->get_int(0, 0));
CHECK(*subtab_0 == two_subtab);
CHECK(*subtab_1 == Table());
}
// Check that we can also create ConstRow's from `const Table`
{
const Table& const_table = table;
ConstRow row_0 = const_table[0];
ConstRow row_1 = const_table[1];
CHECK_EQUAL(0, row_0.get_int(0));
CHECK_EQUAL(5651, row_1.get_int(0));
}
// Check that we can get the table and the row index from a Row
{
Row row_0 = table[0];
Row row_1 = table[1];
CHECK_EQUAL(&table, row_0.get_table());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
}
}
TEST(Table_RowAccessorLinks)
{
Group group;
TableRef target_table = group.add_table("target");
target_table->add_column(type_Int, "");
target_table->add_empty_row(16);
TableRef origin_table = group.add_table("origin");
origin_table->add_column_link(type_Link, "", *target_table);
origin_table->add_column_link(type_LinkList, "", *target_table);
origin_table->add_empty_row(2);
Row source_row_1 = origin_table->get(0);
Row source_row_2 = origin_table->get(1);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
// Set links
source_row_1.set_link(0, 7);
source_row_2.set_link(0, 13);
CHECK(!source_row_1.is_null_link(0));
CHECK(!source_row_2.is_null_link(0));
CHECK_EQUAL(7, source_row_1.get_link(0));
CHECK_EQUAL(13, source_row_2.get_link(0));
CHECK_EQUAL(1, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(7).get_backlink(*origin_table, 0, 0));
CHECK_EQUAL(1, target_table->get(13).get_backlink(*origin_table, 0, 0));
// Nullify links
source_row_1.nullify_link(0);
source_row_2.nullify_link(0);
CHECK(source_row_1.is_null_link(0));
CHECK(source_row_2.is_null_link(0));
CHECK_EQUAL(0, target_table->get(7).get_backlink_count(*origin_table, 0));
CHECK_EQUAL(0, target_table->get(13).get_backlink_count(*origin_table, 0));
// Add stuff to link lists
LinkViewRef link_list_1 = source_row_1.get_linklist(1);
LinkViewRef link_list_2 = source_row_2.get_linklist(1);
link_list_1->add(15);
link_list_2->add(11);
link_list_2->add(15);
CHECK(!source_row_1.linklist_is_empty(1));
CHECK(!source_row_2.linklist_is_empty(1));
CHECK_EQUAL(1, source_row_1.get_link_count(1));
CHECK_EQUAL(2, source_row_2.get_link_count(1));
CHECK_EQUAL(1, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(2, target_table->get(15).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(1, target_table->get(11).get_backlink(*origin_table, 1, 0));
size_t back_link_1 = target_table->get(15).get_backlink(*origin_table, 1, 0);
size_t back_link_2 = target_table->get(15).get_backlink(*origin_table, 1, 1);
CHECK((back_link_1 == 0 && back_link_2 == 1) || (back_link_1 == 1 && back_link_2 == 0));
// Clear link lists
link_list_1->clear();
link_list_2->clear();
CHECK(source_row_1.linklist_is_empty(1));
CHECK(source_row_2.linklist_is_empty(1));
CHECK_EQUAL(0, source_row_1.get_link_count(1));
CHECK_EQUAL(0, source_row_2.get_link_count(1));
CHECK_EQUAL(0, target_table->get(11).get_backlink_count(*origin_table, 1));
CHECK_EQUAL(0, target_table->get(15).get_backlink_count(*origin_table, 1));
}
TEST(Table_RowAccessorDetach)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
Row row = table[0];
CHECK(row.is_attached());
row.detach();
CHECK(!row.is_attached());
row = table[0];
CHECK(row.is_attached());
}
TEST(Table_RowAccessor_DetachedRowExpr)
{
// Check that it is possible to create a detached RowExpr from scratch.
BasicRowExpr<Table> row;
CHECK_NOT(row.is_attached());
}
TEST(Table_RowAccessorCopyAndAssign)
{
Table table;
const Table& ctable = table;
table.add_column(type_Int, "");
table.add_empty_row(3);
table.set_int(0, 0, 750);
table.set_int(0, 1, 751);
table.set_int(0, 2, 752);
{
// Check copy construction of row accessor from row expression
Row row_1 = table[0]; // Copy construct `Row` from `RowExpr`
ConstRow crow_1 = table[1]; // Copy construct `ConstRow` from `RowExpr`
ConstRow crow_2 = ctable[2]; // Copy construct `ConstRow` from `ConstRowExpr`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
// Check copy construction of row accessor from other row accessor
Row drow_1;
ConstRow dcrow_1;
CHECK(!drow_1.is_attached());
CHECK(!dcrow_1.is_attached());
Row drow_2 = drow_1; // Copy construct `Row` from detached `Row`
ConstRow dcrow_2 = drow_1; // Copy construct `ConstRow` from detached `Row`
ConstRow dcrow_3 = dcrow_1; // Copy construct `ConstRow` from detached `ConstRow`
Row row_2 = row_1; // Copy construct `Row` from attached `Row`
ConstRow crow_3 = row_1; // Copy construct `ConstRow` from attached `Row`
ConstRow crow_4 = crow_1; // Copy construct `ConstRow` from attached `ConstRow`
CHECK(!drow_2.is_attached());
CHECK(!dcrow_2.is_attached());
CHECK(!dcrow_3.is_attached());
CHECK(row_2.is_attached());
CHECK(crow_3.is_attached());
CHECK(crow_4.is_attached());
CHECK(!drow_2.get_table());
CHECK(!dcrow_2.get_table());
CHECK(!dcrow_3.get_table());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(&table, crow_4.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(0, crow_3.get_index());
CHECK_EQUAL(1, crow_4.get_index());
}
table.verify();
// Check assignment of row expression to row accessor
{
Row row;
ConstRow crow_1, crow_2;
row = table[0]; // Assign `RowExpr` to detached `Row`
crow_1 = table[1]; // Assign `RowExpr` to detached `ConstRow`
crow_2 = ctable[2]; // Assign `ConstRowExpr` to detached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row = table[1]; // Assign `RowExpr` to attached `Row`
crow_1 = table[2]; // Assign `RowExpr` to attached `ConstRow`
crow_2 = ctable[0]; // Assign `ConstRowExpr` to attached `ConstRow`
CHECK(row.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(1, row.get_index());
CHECK_EQUAL(2, crow_1.get_index());
CHECK_EQUAL(0, crow_2.get_index());
}
// Check assignment of row accessor to row accessor
{
Row drow, row_1;
ConstRow dcrow, crow_1, crow_2;
row_1 = row_1; // Assign detached `Row` to self
crow_1 = crow_1; // Assign detached `ConstRow` to self
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
row_1 = drow; // Assign detached `Row` to detached `Row`
crow_1 = drow; // Assign detached `Row` to detached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to detached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
Row row_2 = table[0];
Row row_3 = table[1];
ConstRow crow_3 = table[2];
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK(crow_3.is_attached());
CHECK_EQUAL(&table, row_2.get_table());
CHECK_EQUAL(&table, row_3.get_table());
CHECK_EQUAL(&table, crow_3.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(1, row_3.get_index());
CHECK_EQUAL(2, crow_3.get_index());
row_1 = row_2; // Assign attached `Row` to detached `Row`
crow_1 = row_3; // Assign attached `Row` to detached `ConstRow`
crow_2 = crow_3; // Assign attached `ConstRow` to detached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
CHECK_EQUAL(2, crow_2.get_index());
row_1 = row_1; // Assign attached `Row` to self
crow_1 = crow_1; // Assign attached `ConstRow` to self
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, crow_1.get_index());
Row row_4 = table[2];
Row row_5 = table[0];
ConstRow crow_4 = table[1];
row_1 = row_4; // Assign attached `Row` to attached `Row`
crow_1 = row_5; // Assign attached `Row` to attached `ConstRow`
crow_2 = crow_4; // Assign attached `ConstRow` to attached `ConstRow`
CHECK(row_1.is_attached());
CHECK(crow_1.is_attached());
CHECK(crow_2.is_attached());
CHECK_EQUAL(&table, row_1.get_table());
CHECK_EQUAL(&table, crow_1.get_table());
CHECK_EQUAL(&table, crow_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(0, crow_1.get_index());
CHECK_EQUAL(1, crow_2.get_index());
row_1 = drow; // Assign detached `Row` to attached `Row`
crow_1 = drow; // Assign detached `Row` to attached `ConstRow`
crow_2 = dcrow; // Assign detached `ConstRow` to attached `ConstRow`
CHECK(!row_1.is_attached());
CHECK(!crow_1.is_attached());
CHECK(!crow_2.is_attached());
}
}
TEST(Table_RowAccessorCopyConstructionBug)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row();
BasicRowExpr<Table> row_expr(table[0]);
BasicRow<Table> row_from_expr(row_expr);
BasicRow<Table> row_copy(row_from_expr);
table.remove(0);
CHECK_NOT(row_from_expr.is_attached());
CHECK_NOT(row_copy.is_attached());
}
TEST(Table_RowAccessorAssignMultipleTables)
{
Table tables[2];
for (int i = 0; i < 2; ++i) {
tables[i].add_column(type_Int, "");
tables[i].add_empty_row(3);
tables[i].set_int(0, 0, 750);
tables[i].set_int(0, 1, 751);
tables[i].set_int(0, 2, 752);
}
Row row_1 = tables[0][2];
Row row_2 = tables[1][2];
Row row_3 = tables[0][2];
row_1 = tables[1][2]; // Assign attached `Row` to a different table via RowExpr
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 2);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 1);
row_1 = row_3; // Assign attached `Row` to a different table via Row
// Veriy that the correct accessors are updated when removing from a table
tables[0].remove(0);
CHECK_EQUAL(row_1.get_index(), 0);
CHECK_EQUAL(row_2.get_index(), 2);
CHECK_EQUAL(row_3.get_index(), 0);
}
TEST(Table_RowAccessorRetain)
{
// Create a table with two rows
TableRef parent = Table::create();
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
ConstRow row_1 = (*parent)[0];
ConstRow row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that row insertion does not detach the row accessors, and that the
// row indexes is properly adjusted
parent->insert_empty_row(1); // Between
parent->add_empty_row(); // After
parent->insert_empty_row(0); // Before
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->insert_empty_row(1); // Immediately before row_1
parent->insert_empty_row(5); // Immediately after row_2
parent->insert_empty_row(3); // Immediately after row_1
parent->insert_empty_row(5); // Immediately before row_2
parent->verify();
CHECK_EQUAL(9, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(2, row_1.get_index());
CHECK_EQUAL(6, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of rows (other than row_1 and row_2) does not detach
// the row accessors, and that the row indexes is properly adjusted
parent->remove(3); // Immediately after row_1
parent->remove(1); // Immediately before row_1
parent->remove(3); // Immediately before row_2
parent->remove(4); // Immediately after row_2
parent->verify();
CHECK_EQUAL(5, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
parent->remove(4); // After
parent->remove(0); // Before
parent->remove(1); // Between
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of first row detaches row_1
parent->remove(0);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(!row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_2.get_index());
CHECK_EQUAL(227, row_2.get_int(0));
// Restore first row and recover row_1
parent->insert_empty_row(0);
parent->set_int(0, 0, 27);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of second row detaches row_2
parent->remove(1);
parent->verify();
CHECK_EQUAL(1, parent->size());
CHECK(row_1.is_attached());
CHECK(!row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
// Restore second row and recover row_2
parent->add_empty_row();
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that descriptor modifications do not affect the row accessors (as
// long as we do not remove the last column)
parent->add_column(type_String, "x");
parent->insert_column(0, type_Float, "y");
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(1));
CHECK_EQUAL(227, row_2.get_int(1));
parent->remove_column(0);
parent->remove_column(1);
parent->verify();
CHECK_EQUAL(2, parent->size());
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
CHECK_EQUAL(27, row_1.get_int(0));
CHECK_EQUAL(227, row_2.get_int(0));
// Check that removal of the last column detaches all row accessors
parent->remove_column(0);
parent->verify();
CHECK_EQUAL(0, parent->get_column_count());
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
// Restore rows and recover row accessors
parent->add_column(type_Int, "a");
parent->add_empty_row(2);
parent->set_int(0, 0, 27);
parent->set_int(0, 1, 227);
parent->verify();
CHECK_EQUAL(2, parent->size());
row_1 = (*parent)[0];
row_2 = (*parent)[1];
CHECK(row_1.is_attached());
CHECK(row_2.is_attached());
CHECK_EQUAL(parent.get(), row_1.get_table());
CHECK_EQUAL(parent.get(), row_2.get_table());
CHECK_EQUAL(0, row_1.get_index());
CHECK_EQUAL(1, row_2.get_index());
// Check that clearing of the table detaches all row accessors
parent->clear();
parent->verify();
CHECK_EQUAL(0, parent->size());
CHECK(!row_1.is_attached());
CHECK(!row_2.is_attached());
}
TEST(Table_SubtableRowAccessorsRetain)
{
// Create a mixed and a regular subtable each with one row
TableRef parent = Table::create();
parent->add_column(type_Mixed, "a");
parent->add_column(type_Table, "b");
DescriptorRef subdesc = parent->get_subdescriptor(1);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row();
parent->set_mixed(0, 0, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(0, 0);
CHECK(mixed && mixed->is_attached());
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
TableRef regular = parent->get_subtable(1, 0);
CHECK(regular && regular->is_attached());
regular->add_empty_row();
regular->set_int(0, 0, 29);
CHECK(mixed->size() == 1);
CHECK(regular->size() == 1);
ConstRow row_m = (*mixed)[0];
ConstRow row_r = (*regular)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a mixed subtable are detached if the
// subtable is overridden
parent->set_mixed(0, 0, Mixed("foo"));
CHECK(!mixed->is_attached());
CHECK(regular->is_attached());
CHECK(!row_m.is_attached());
CHECK(row_r.is_attached());
// Restore mixed
parent->set_mixed(0, 0, Mixed::subtable_tag());
mixed = parent->get_subtable(0, 0);
CHECK(mixed);
CHECK(mixed->is_attached());
mixed->add_column(type_Int, "mixed_2");
mixed->add_empty_row();
mixed->set_int(0, 0, 19);
CHECK(regular->is_attached());
CHECK_EQUAL(1, mixed->size());
CHECK_EQUAL(1, regular->size());
row_m = (*mixed)[0];
CHECK_EQUAL(19, row_m.get_int(0));
CHECK_EQUAL(29, row_r.get_int(0));
// Check that all row accessors in a regular subtable are detached if the
// subtable is overridden
parent->set_subtable(1, 0, nullptr); // Clear
CHECK(mixed->is_attached());
CHECK(regular->is_attached());
CHECK(row_m.is_attached());
CHECK(!row_r.is_attached());
}
TEST(Table_MoveLastOverRetain)
{
// Create three parent tables, each with with 5 rows, and each row
// containing one regular and one mixed subtable
TableRef parent_1, parent_2, parent_3;
for (int i = 0; i < 3; ++i) {
TableRef& parent = i == 0 ? parent_1 : i == 1 ? parent_2 : parent_3;
parent = Table::create();
parent->add_column(type_Table, "a");
parent->add_column(type_Mixed, "b");
DescriptorRef subdesc = parent->get_subdescriptor(0);
subdesc->add_column(type_Int, "regular");
parent->add_empty_row(5);
for (int row_ndx = 0; row_ndx < 5; ++row_ndx) {
TableRef regular = parent->get_subtable(0, row_ndx);
regular->add_empty_row();
regular->set_int(0, 0, 10 + row_ndx);
parent->set_mixed(1, row_ndx, Mixed::subtable_tag());
TableRef mixed = parent->get_subtable(1, row_ndx);
mixed->add_column(type_Int, "mixed");
mixed->add_empty_row();
mixed->set_int(0, 0, 20 + row_ndx);
}
}
// Use first table to check with accessors on row indexes 0, 1, and 4, but
// none at index 2 and 3.
{
TableRef parent = parent_1;
ConstRow row_0 = (*parent)[0];
ConstRow row_1 = (*parent)[1];
ConstRow row_4 = (*parent)[4];
TableRef regular_0 = parent->get_subtable(0, 0);
TableRef regular_1 = parent->get_subtable(0, 1);
TableRef regular_4 = parent->get_subtable(0, 4);
TableRef mixed_0 = parent->get_subtable(1, 0);
TableRef mixed_1 = parent->get_subtable(1, 1);
TableRef mixed_4 = parent->get_subtable(1, 4);
CHECK(row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(4, row_4.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0, 0));
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(14, regular_4->get_int(0, 0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_4 && mixed_4->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0, 0));
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(24, mixed_4->get_int(0, 0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(2, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(14, regular_4->get_int(0, 0));
CHECK_EQUAL(regular_1, parent->get_subtable(0, 1));
CHECK_EQUAL(regular_4, parent->get_subtable(0, 2));
CHECK(!mixed_0->is_attached());
CHECK(mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(24, mixed_4->get_int(0, 0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1, 1));
CHECK_EQUAL(mixed_4, parent->get_subtable(1, 2));
// Perform two more 'move last over' operations which brings the number
// of rows down from 3 to 1
parent->move_last_over(1); // Move row at index 2 to index 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_1.is_attached());
CHECK(row_4.is_attached());
CHECK_EQUAL(0, row_4.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_1->is_attached());
CHECK(regular_4->is_attached());
CHECK_EQUAL(14, regular_4->get_int(0, 0));
CHECK_EQUAL(regular_4, parent->get_subtable(0, 0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(mixed_4->is_attached());
CHECK_EQUAL(24, mixed_4->get_int(0, 0));
CHECK_EQUAL(mixed_4, parent->get_subtable(1, 0));
}
// Use second table to check with accessors on row indexes 0, 2, and 3, but
// none at index 1 and 4.
{
TableRef parent = parent_2;
ConstRow row_0 = (*parent)[0];
ConstRow row_2 = (*parent)[2];
ConstRow row_3 = (*parent)[3];
TableRef regular_0 = parent->get_subtable(0, 0);
TableRef regular_2 = parent->get_subtable(0, 2);
TableRef regular_3 = parent->get_subtable(0, 3);
TableRef mixed_0 = parent->get_subtable(1, 0);
TableRef mixed_2 = parent->get_subtable(1, 2);
TableRef mixed_3 = parent->get_subtable(1, 3);
CHECK(row_0.is_attached());
CHECK(row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_0.get_index());
CHECK_EQUAL(2, row_2.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_0->is_attached());
CHECK(regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(10, regular_0->get_int(0, 0));
CHECK_EQUAL(12, regular_2->get_int(0, 0));
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK(mixed_0 && mixed_0->is_attached());
CHECK(mixed_2 && mixed_2->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(20, mixed_0->get_int(0, 0));
CHECK_EQUAL(22, mixed_2->get_int(0, 0));
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_0.is_attached());
CHECK(!row_2.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_0->is_attached());
CHECK(!regular_2->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_0->is_attached());
CHECK(!mixed_2->is_attached());
CHECK(!mixed_3->is_attached());
}
// Use third table to check with accessors on row indexes 1 and 3, but none
// at index 0, 2, and 4.
{
TableRef parent = parent_3;
ConstRow row_1 = (*parent)[1];
ConstRow row_3 = (*parent)[3];
TableRef regular_1 = parent->get_subtable(0, 1);
TableRef regular_3 = parent->get_subtable(0, 3);
TableRef mixed_1 = parent->get_subtable(1, 1);
TableRef mixed_3 = parent->get_subtable(1, 3);
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(3, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK(mixed_1 && mixed_1->is_attached());
CHECK(mixed_3 && mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
// Perform two 'move last over' operations which brings the number of
// rows down from 5 to 3
parent->move_last_over(2); // Move row at index 4 to index 2
parent->move_last_over(0); // Move row at index 3 to index 0
CHECK(row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(1, row_1.get_index());
CHECK_EQUAL(0, row_3.get_index());
CHECK(regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(11, regular_1->get_int(0, 0));
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_1, parent->get_subtable(0, 1));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(21, mixed_1->get_int(0, 0));
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_1, parent->get_subtable(1, 1));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one more 'move last over' operation which brings the number
// of rows down from 3 to 2
parent->move_last_over(1); // Move row at index 2 to index 1
CHECK(!row_1.is_attached());
CHECK(row_3.is_attached());
CHECK_EQUAL(0, row_3.get_index());
CHECK(!regular_1->is_attached());
CHECK(regular_3->is_attached());
CHECK_EQUAL(13, regular_3->get_int(0, 0));
CHECK_EQUAL(regular_3, parent->get_subtable(0, 0));
CHECK(!mixed_1->is_attached());
CHECK(mixed_3->is_attached());
CHECK_EQUAL(23, mixed_3->get_int(0, 0));
CHECK_EQUAL(mixed_3, parent->get_subtable(1, 0));
// Perform one final 'move last over' operation which brings the number
// of rows down from 2 to 1
parent->move_last_over(0); // Move row at index 1 to index 0
CHECK(!row_1.is_attached());
CHECK(!row_3.is_attached());
CHECK(!regular_1->is_attached());
CHECK(!regular_3->is_attached());
CHECK(!mixed_1->is_attached());
CHECK(!mixed_3->is_attached());
}
}
TEST(Table_EnumStringInsertEmptyRow)
{
Table table;
table.add_column(type_String, "");
table.add_empty_row(128);
for (int i = 0; i < 128; ++i)
table.set_string(0, i, "foo");
DescriptorRef desc = table.get_descriptor();
CHECK_EQUAL(0, desc->get_num_unique_values(0));
table.optimize();
// Make sure we now have an enumerated strings column
CHECK_EQUAL(1, desc->get_num_unique_values(0));
table.add_empty_row();
CHECK_EQUAL("", table.get_string(0, 128));
}
TEST(Table_InsertColumnMaintainsBacklinkIndices)
{
Group g;
TableRef t0 = g.add_table("hrnetprsafd");
TableRef t1 = g.add_table("qrsfdrpnkd");
t1->add_column_link(type_Link, "bbb", *t0);
t1->add_column_link(type_Link, "ccc", *t0);
t1->insert_column(0, type_Int, "aaa");
t1->add_empty_row();
t0->add_column(type_Int, "foo");
t0->add_empty_row();
t1->remove_column(0);
t1->set_link(0, 0, 0);
t1->remove_column(0);
t1->set_link(0, 0, 0);
}
TEST(Table_MultipleLinkColumnsToSelf)
{
Group g;
TableRef t = g.add_table("A");
t->insert_column_link(0, type_Link, "e", *t);
t->insert_column_link(1, type_LinkList, "f", *t);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
_impl::TableFriend::move_column(*t->get_descriptor(), 0, 1);
g.verify();
t->get_linklist(0, 0)->add(0);
g.verify();
}
TEST(Table_MultipleLinkColumnsToOther)
{
Group g;
TableRef t = g.add_table("A");
TableRef t2 = g.add_table("B");
t->insert_column_link(0, type_Link, "e", *t2);
t->insert_column_link(1, type_LinkList, "f", *t);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
_impl::TableFriend::move_column(*t->get_descriptor(), 0, 1);
g.verify();
t->get_linklist(0, 0)->add(0);
g.verify();
}
TEST(Table_MultipleLinkColumnsMoveTables)
{
Group g;
TableRef t = g.add_table("A");
TableRef t2 = g.add_table("B");
t->insert_column_link(0, type_Link, "e", *t);
t->insert_column_link(1, type_LinkList, "f", *t);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
_impl::TableFriend::move_column(*t->get_descriptor(), 0, 1);
g.verify();
t->get_linklist(0, 0)->add(0);
g.verify();
g.move_table(0, 1);
g.verify();
g.move_table(1, 0);
g.verify();
}
TEST(Table_MultipleLinkColumnsMoveTablesCrossLinks)
{
Group g;
TableRef t = g.add_table("A");
TableRef t2 = g.add_table("B");
t->insert_column_link(0, type_Link, "e", *t2);
t->insert_column_link(1, type_LinkList, "f", *t);
t->insert_column_link(2, type_Link, "g", *t2);
t->add_empty_row();
t->get_linklist(1, 0)->add(0);
g.move_table(0, 1);
g.verify();
_impl::TableFriend::move_column(*t->get_descriptor(), 1, 2);
g.verify();
t->get_linklist(2, 0)->add(0);
g.verify();
g.move_table(1, 0);
g.verify();
_impl::TableFriend::move_column(*t->get_descriptor(), 1, 0);
g.verify();
}
TEST(Table_AddColumnWithThreeLevelBptree)
{
Table table;
table.add_column(type_Int, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE * REALM_MAX_BPNODE_SIZE + 1);
table.add_column(type_Int, "");
table.verify();
}
TEST(Table_ClearWithTwoLevelBptree)
{
Table table;
table.add_column(type_Mixed, "");
table.add_empty_row(REALM_MAX_BPNODE_SIZE + 1);
table.clear();
table.verify();
}
TEST(Table_IndexStringDelete)
{
Table t;
t.add_column(type_String, "str");
t.add_search_index(0);
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
std::string out(util::to_string(i));
t.set_string(0, i, out);
}
t.clear();
for (size_t i = 0; i < 1000; ++i) {
t.add_empty_row();
std::string out(util::to_string(i));
t.set_string(0, i, out);
}
}
TEST(Table_Nulls)
{
// 'round' lets us run this entire test both with and without index and with/without optimize/enum
for (size_t round = 0; round < 5; round++) {
Table t;
TableView tv;
t.add_column(type_String, "str", true /*nullable*/);
if (round == 1)
t.add_search_index(0);
else if (round == 2)
t.optimize(true);
else if (round == 3) {
t.add_search_index(0);
t.optimize(true);
}
else if (round == 4) {
t.optimize(true);
t.add_search_index(0);
}
t.add_empty_row(3);
t.set_string(0, 0, "foo"); // short strings
t.set_string(0, 1, "");
t.set_string(0, 2, realm::null());
CHECK_EQUAL(1, t.count_string(0, "foo"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "foo"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "foo");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYY"); // medium strings (< 64)
CHECK_EQUAL(1, t.count_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0, t.find_first_string(0, "xxxxxxxxxxYYYYYYYYYY"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYY");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
// long strings (>= 64)
t.set_string(0, 0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, t.count_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.count_string(0, ""));
CHECK_EQUAL(1, t.count_string(0, realm::null()));
CHECK_EQUAL(0,
t.find_first_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx"));
CHECK_EQUAL(1, t.find_first_string(0, ""));
CHECK_EQUAL(2, t.find_first_string(0, realm::null()));
tv = t.find_all_string(0, "xxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxxYYYYYYYYYYxxxxxxxxxx");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(0, tv.get_source_ndx(0));
tv = t.find_all_string(0, "");
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(1, tv.get_source_ndx(0));
tv = t.find_all_string(0, realm::null());
CHECK_EQUAL(1, tv.size());
CHECK_EQUAL(2, tv.get_source_ndx(0));
}
{
Table t;
t.add_column(type_Int, "int", true); // nullable = true
t.add_column(type_Bool, "bool", true); // nullable = true
t.add_column(type_OldDateTime, "bool", true); // nullable = true
t.add_empty_row(2);
t.set_int(0, 0, 65);
t.set_bool(1, 0, false);
t.set_olddatetime(2, 0, OldDateTime(3));
CHECK_EQUAL(65, t.get_int(0, 0));
CHECK_EQUAL(false, t.get_bool(1, 0));
CHECK_EQUAL(OldDateTime(3), t.get_olddatetime(2, 0));
CHECK_EQUAL(65, t.maximum_int(0));
CHECK_EQUAL(65, t.minimum_int(0));
CHECK_EQUAL(OldDateTime(3), t.maximum_olddatetime(2));
CHECK_EQUAL(OldDateTime(3), t.minimum_olddatetime(2));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(!t.is_null(2, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK(t.is_null(2, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(1, t.find_first_null(2));
CHECK_EQUAL(not_found, t.find_first_int(0, -1));
CHECK_EQUAL(not_found, t.find_first_bool(1, true));
CHECK_EQUAL(not_found, t.find_first_olddatetime(2, OldDateTime(5)));
CHECK_EQUAL(0, t.find_first_int(0, 65));
CHECK_EQUAL(0, t.find_first_bool(1, false));
CHECK_EQUAL(0, t.find_first_olddatetime(2, OldDateTime(3)));
t.set_null(0, 0);
t.set_null(1, 0);
t.set_null(2, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
CHECK(t.is_null(2, 0));
}
{
Table t;
t.add_column(type_Float, "float", true); // nullable = true
t.add_column(type_Double, "double", true); // nullable = true
t.add_empty_row(2);
t.set_float(0, 0, 1.23f);
t.set_double(1, 0, 12.3);
CHECK_EQUAL(1.23f, t.get_float(0, 0));
CHECK_EQUAL(12.3, t.get_double(1, 0));
CHECK_EQUAL(1.23f, t.maximum_float(0));
CHECK_EQUAL(1.23f, t.minimum_float(0));
CHECK_EQUAL(12.3, t.maximum_double(1));
CHECK_EQUAL(12.3, t.minimum_double(1));
CHECK(!t.is_null(0, 0));
CHECK(!t.is_null(1, 0));
CHECK(t.is_null(0, 1));
CHECK(t.is_null(1, 1));
CHECK_EQUAL(1, t.find_first_null(0));
CHECK_EQUAL(1, t.find_first_null(1));
CHECK_EQUAL(not_found, t.find_first_float(0, 2.22f));
CHECK_EQUAL(not_found, t.find_first_double(1, 2.22));
CHECK_EQUAL(0, t.find_first_float(0, 1.23f));
CHECK_EQUAL(0, t.find_first_double(1, 12.3));
t.set_null(0, 0);
t.set_null(1, 0);
CHECK(t.is_null(0, 0));
CHECK(t.is_null(1, 0));
}
}
TEST(Table_InsertSubstring)
{
struct Fixture {
Table table;
Fixture()
{
table.add_column(type_String, "");
table.add_empty_row();
table.set_string(0, 0, "0123456789");
}
};
{
Fixture f;
f.table.insert_substring(0, 0, 0, "x");
CHECK_EQUAL("x0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.insert_substring(0, 0, 5, "x");
CHECK_EQUAL("01234x56789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.insert_substring(0, 0, 10, "x");
CHECK_EQUAL("0123456789x", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.insert_substring(0, 0, 5, "");
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.insert_substring(1, 0, 5, "x"), LogicError::column_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.insert_substring(0, 1, 5, "x"), LogicError::row_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.insert_substring(0, 0, 11, "x"), LogicError::string_position_out_of_range);
}
}
TEST(Table_RemoveSubstring)
{
struct Fixture {
Table table;
Fixture()
{
table.add_column(type_String, "");
table.add_empty_row();
table.set_string(0, 0, "0123456789");
}
};
{
Fixture f;
f.table.remove_substring(0, 0, 0, 1);
CHECK_EQUAL("123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 9, 1);
CHECK_EQUAL("012345678", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 0);
CHECK_EQUAL("", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 5);
CHECK_EQUAL("01234", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 10);
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 5, 1000);
CHECK_EQUAL("01234", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 10, 0);
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
f.table.remove_substring(0, 0, 10, 1);
CHECK_EQUAL("0123456789", f.table.get_string(0, 0));
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.remove_substring(1, 0, 5, 1), LogicError::column_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.remove_substring(0, 1, 5, 1), LogicError::row_index_out_of_range);
}
{
Fixture f;
CHECK_LOGIC_ERROR(f.table.remove_substring(0, 0, 11, 1), LogicError::string_position_out_of_range);
}
}
TEST(Table_SwapRowsThenMoveLastOverWithBacklinks)
{
// Attempts to trigger bug where LinkColumn::swap_rows() would only swap its backlinks but forgot
// to swap its own values
Group g;
TableRef t1 = g.add_table("t1");
TableRef t2 = g.add_table("t2");
t1->add_column(type_Int, "i");
t2->add_column_link(type_Link, "l", *t1);
t1->add_empty_row(2);
t2->add_empty_row(2);
t2->set_link(0, 0, 0);
t2->set_link(0, 1, 1);
t2->swap_rows(0, 1);
t2->verify();
t2->move_last_over(0);
t2->verify();
}
TEST(Table_RowAccessor_Null)
{
Table table;
size_t col_bool = table.add_column(type_Bool, "bool", true);
size_t col_int = table.add_column(type_Int, "int", true);
size_t col_string = table.add_column(type_String, "string", true);
size_t col_float = table.add_column(type_Float, "float", true);
size_t col_double = table.add_column(type_Double, "double", true);
size_t col_date = table.add_column(type_OldDateTime, "date", true);
size_t col_binary = table.add_column(type_Binary, "binary", true);
size_t col_timestamp = table.add_column(type_Timestamp, "timestamp", true);
{
table.add_empty_row();
Row row = table[0];
row.set_null(col_bool);
row.set_null(col_int);
row.set_string(col_string, realm::null());
row.set_null(col_float);
row.set_null(col_double);
row.set_null(col_date);
row.set_binary(col_binary, BinaryData());
row.set_null(col_timestamp);
}
{
table.add_empty_row();
Row row = table[1];
row.set_bool(col_bool, true);
row.set_int(col_int, 1);
row.set_string(col_string, "1");
row.set_float(col_float, 1.0);
row.set_double(col_double, 1.0);
row.set_olddatetime(col_date, OldDateTime(1));
row.set_binary(col_binary, BinaryData("a"));
row.set_timestamp(col_timestamp, Timestamp(1, 2));
}
{
Row row = table[0];
CHECK(row.is_null(col_bool));
CHECK(row.is_null(col_int));
CHECK(row.is_null(col_string));
CHECK(row.is_null(col_float));
CHECK(row.is_null(col_double));
CHECK(row.is_null(col_date));
CHECK(row.is_null(col_binary));
CHECK(row.is_null(col_timestamp));
}
{
Row row = table[1];
CHECK_EQUAL(true, row.get_bool(col_bool));
CHECK_EQUAL(1, row.get_int(col_int));
CHECK_EQUAL("1", row.get_string(col_string));
CHECK_EQUAL(1.0, row.get_float(col_float));
CHECK_EQUAL(1.0, row.get_double(col_double));
CHECK_EQUAL(OldDateTime(1), row.get_olddatetime(col_date));
CHECK_EQUAL(BinaryData("a"), row.get_binary(col_binary));
CHECK_EQUAL(Timestamp(1, 2), row.get_timestamp(col_timestamp));
}
}
// This triggers a severe bug in the Array::alloc() allocator in which its capacity-doubling
// scheme forgets to test of the doubling has overflowed the maximum allowed size of an
// array which is 2^24 - 1 bytes
TEST(Table_AllocatorCapacityBug)
{
std::unique_ptr<char[]> buf(new char[20000000]);
// First a simple trigger of `Assertion failed: value <= 0xFFFFFFL [26000016, 16777215]`
{
ref_type ref = BinaryColumn::create(Allocator::get_default(), 0, false);
BinaryColumn c(Allocator::get_default(), ref, true);
c.add(BinaryData(buf.get(), 13000000));
c.set(0, BinaryData(buf.get(), 14000000));
c.destroy();
}
// Now a small fuzzy test to catch other such bugs
{
Table t;
t.add_column(type_Binary, "", true);
for (size_t j = 0; j < 100; j++) {
size_t r = (j * 123456789 + 123456789) % 100;
if (r < 20) {
t.add_empty_row();
}
else if (t.size() > 0 && t.size() < 5) {
// Set only if there are no more than 4 rows, else it takes up too much space on devices (4 * 16 MB
// worst case now)
size_t row = (j * 123456789 + 123456789) % t.size();
size_t len = (j * 123456789 + 123456789) % 16000000;
BinaryData bd;
bd = BinaryData(buf.get(), len);
t.set_binary(0, row, bd);
}
else if (t.size() >= 4) {
t.clear();
}
}
}
}
// Exposes crash when setting a int, float or double that has its least significant bit set
TEST(Table_MixedCrashValues)
{
GROUP_TEST_PATH(path);
const char* encryption_key = nullptr;
Group group(path, encryption_key, Group::mode_ReadWrite);
TableRef table = group.add_table("t");
table->add_column(type_Mixed, "m");
table->add_empty_row(3);
table->set_mixed(0, 0, Mixed(int64_t(-1)));
table->set_mixed(0, 1, Mixed(2.0f));
table->set_mixed(0, 2, Mixed(2.0));
CHECK_EQUAL(table->get_mixed(0, 0).get_int(), int64_t(-1));
CHECK_EQUAL(table->get_mixed(0, 1).get_float(), 2.0f);
CHECK_EQUAL(table->get_mixed(0, 2).get_double(), 2.0);
group.verify();
}
TEST(Table_ChangeLinkTargets_Links)
{
Group g;
TableRef t0 = g.add_table("t0");
TableRef t1 = g.add_table("t1");
t0->add_column_link(type_Link, "link", *t1);
t1->add_column(type_Int, "int");
t0->add_empty_row(10);
t1->add_empty_row(10);
for (int i = 0; i < 10; ++i) {
t0->set_link(0, i, i);
t1->set_int(0, i, i);
}
Row replaced_row = t1->get(0);
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 1);
t1->change_link_targets(0, 9);
CHECK(replaced_row.is_attached());
CHECK_EQUAL(t0->get_link(0, 0), 9);
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 0);
}
TEST(Table_ChangeLinkTargets_LinkLists)
{
Group g;
TableRef t0 = g.add_table("t0");
TableRef t1 = g.add_table("t1");
t0->add_column_link(type_LinkList, "linklist", *t1);
t1->add_column(type_Int, "int");
t0->add_empty_row(10);
t1->add_empty_row(10);
for (int i = 0; i < 10; ++i) {
auto links = t0->get_linklist(0, i);
links->add(i);
links->add((i + 1) % 10);
t1->set_int(0, i, i);
}
Row replaced_row = t1->get(0);
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 2);
t1->change_link_targets(0, 9);
CHECK(replaced_row.is_attached());
CHECK_EQUAL(t1->get_backlink_count(0, *t0, 0), 0);
CHECK_EQUAL(t0->get_linklist(0, 0)->size(), 2);
CHECK_EQUAL(t0->get_linklist(0, 0)->get(0).get_index(), 9);
CHECK_EQUAL(t0->get_linklist(0, 0)->get(1).get_index(), 1);
CHECK_EQUAL(t0->get_linklist(0, 9)->size(), 2);
CHECK_EQUAL(t0->get_linklist(0, 9)->get(0).get_index(), 9);
CHECK_EQUAL(t0->get_linklist(0, 9)->get(1).get_index(), 9);
}
// Minimal test case causing an assertion error because
// backlink columns are storing stale values referencing
// their respective link column index. If a link column
// index changes, the backlink column accessors must also
// be updated.
TEST(Table_MinimalStaleLinkColumnIndex)
{
Group g;
TableRef t = g.add_table("table");
t->add_column(type_Int, "int1");
t->add_search_index(0);
t->add_empty_row(2);
t->set_int(0, 1, 4444);
TableRef t2 = g.add_table("table2");
t2->add_column(type_Int, "int_col");
t2->add_column_link(type_Link, "link", *t);
t2->remove_column(0);
t->set_int_unique(0, 0, 4444); // crashed here
CHECK_EQUAL(t->get_int(0, 0), 4444);
CHECK_EQUAL(t->size(), 1);
}
// This test case is a simplified version of a bug revealed by fuzz testing
// set_int_unique triggers backlinks to update if the element to insert is
// not unique. The expected behaviour is that the new row containing the
// unique int will be removed and the old row will remain; this ensures
// uniques without throwing errors. This test was crashing (assert failed)
// when inserting a unique duplicate because backlink indices hadn't been
// updated after a column had been removed from the table containing the link.
TEST(Table_FuzzTestRevealed_SetUniqueAssert)
{
Group g;
g.add_table("string_index_test_table");
g.get_table(0)->add_search_index(g.get_table(0)->add_column(DataType(0), "aa", true));
g.get_table(0)->add_search_index(g.get_table(0)->add_column(DataType(0), "bb", true));
g.get_table(0)->insert_column(0, DataType(0), "cc", true);
g.get_table(0)->add_search_index(0);
g.get_table(0)->insert_column_link(3, type_Link, "dd", *g.get_table(0));
g.get_table(0)->add_empty_row(225);
{
TableRef t = g.get_table(0);
t->remove_column(1);
}
{
TableRef t = g.get_table(0);
t->remove_column(0);
}
g.get_table(0)->add_empty_row(186);
g.get_table(0)->find_first_int(0, 0);
g.get_table(0)->set_int_unique(0, 255, 1);
g.get_table(0)->find_first_int(0, 0);
g.get_table(0)->set_null(0, 53);
g.get_table(0)->set_int_unique(0, 97, 'l');
g.get_table(0)->add_empty_row(85);
g.get_table(0)->set_int_unique(0, 100, 'l'); // duplicate
CHECK_EQUAL(g.get_table(0)->get_int(0, 97), 'l');
CHECK_EQUAL(g.get_table(0)->get_int(0, 100), 0);
}
TEST(Table_InsertUniqueDuplicate_LinkedColumns)
{
Group g;
TableRef t = g.add_table("table");
t->add_column(type_Int, "int1");
t->add_search_index(0);
t->add_empty_row(2);
t->set_int_unique(0, 0, 42);
t->set_int_unique(0, 1, 42);
CHECK_EQUAL(t->size(), 1);
CHECK_EQUAL(t->get_int(0, 0), 42);
t->insert_column(0, type_String, "string1");
t->add_search_index(0);
t->add_empty_row(1);
t->set_string_unique(0, 0, "fourty-two");
t->set_string_unique(0, 1, "fourty-two");
CHECK_EQUAL(t->size(), 1);
CHECK_EQUAL(t->get_string(0, 0), "fourty-two");
CHECK_EQUAL(t->get_int(1, 0), 42);
TableRef t2 = g.add_table("table2");
t2->add_column(type_Int, "int_col");
t2->add_column(type_String, "string_col");
t2->add_column_link(type_Link, "link", *t);
t2->add_search_index(0);
t2->add_search_index(1);
t2->add_empty_row(2);
t2->set_int_unique(0, 0, 43);
t2->set_string_unique(1, 0, "fourty-three");
t2->set_string_unique(1, 1, "FOURTY_THREE");
t2->set_link(2, 0, 0);
t2->set_int_unique(0, 1, 43); // deletes row 1, row 0 is winner
CHECK_EQUAL(t2->size(), 1);
CHECK_EQUAL(t2->get_int(0, 0), 43);
CHECK_EQUAL(t2->get_string(1, 0), "fourty-three");
CHECK_EQUAL(t2->get_link(2, 0), 0);
t2->remove_column(0);
t->insert_empty_row(0); // update t2 link through backlinks
t->set_int(1, 0, 333);
CHECK_EQUAL(t->get_int(1, 0), 333);
CHECK_EQUAL(t->get_int(1, 1), 42);
CHECK_EQUAL(t2->get_link(1, 0), 1); // bumped forward by insert at t(0), updated through backlinks
using df = _impl::DescriptorFriend;
DescriptorRef t2_descriptor = t2->get_descriptor();
df::move_column(*t2_descriptor, 0, 1);
CHECK_EQUAL(t2->get_link(0, 0), 1); // unchanged
t->insert_empty_row(0);
t->set_int(1, 0, 4444);
CHECK_EQUAL(t2->get_link(0, 0), 2); // bumped forward via backlinks
t2->remove_column(1);
CHECK_EQUAL(t2->get_link(0, 0), 2); // unchanged
t->insert_empty_row(0); // update through backlinks
t->set_int(1, 0, 55555);
CHECK_EQUAL(t2->get_link(0, 0), 3);
t->set_int_unique(1, 0, 4444); // duplicate, row 1 wins, move_last_over(0)
CHECK_EQUAL(t2->get_link(0, 0), 0); // changed by duplicate overwrite in linked table via backlinks
t2->insert_column(0, type_Int, "type_Int col");
CHECK_EQUAL(t2->get_link(1, 0), 0); // no change after insert col
t->insert_empty_row(0);
t->set_int(1, 0, 666666);
CHECK_EQUAL(t2->get_link(1, 0), 1); // bumped forward via backlinks
df::move_column(*t2_descriptor, 1, 0); // move backwards
CHECK_EQUAL(t2->get_link(0, 0), 1); // no change
t->insert_empty_row(0);
t->set_int(1, 0, 7777777);
CHECK_EQUAL(t2->get_link(0, 0), 2); // bumped forward via backlinks
t->remove(0);
CHECK_EQUAL(t2->get_link(0, 0), 1); // bumped back via backlinks
}
TEST(Table_DetachedAccessor)
{
Group group;
TableRef table = group.add_table("table");
table->add_column(type_Int, "i");
table->add_column(type_String, "s");
table->add_column(type_Binary, "b");
table->add_column_link(type_Link, "l", *table);
table->add_empty_row(2);
group.remove_table("table");
CHECK_LOGIC_ERROR(table->clear(), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->add_search_index(0), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->remove_search_index(0), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->change_link_targets(0, 1), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->swap_rows(0, 1), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_string(1, 0, ""), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_string_unique(1, 0, ""), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->insert_substring(1, 0, 0, "x"), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->remove_substring(1, 0, 0), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_binary(2, 0, BinaryData()), LogicError::detached_accessor);
CHECK_LOGIC_ERROR(table->set_link(3, 0, 0), LogicError::detached_accessor);
}
// This test reproduces a user reported assertion failure. The problem was
// due to BacklinkColumn::m_origin_column_ndx not being updated when the
// linked table removed/inserted columns (this happened on a migration)
TEST(Table_StaleLinkIndexOnTableRemove)
{
SHARED_GROUP_TEST_PATH(path);
std::unique_ptr<Replication> hist(realm::make_in_realm_history(path));
SharedGroup sg_w(*hist, SharedGroupOptions(crypt_key()));
Group& group_w = const_cast<Group&>(sg_w.begin_read());
LangBindHelper::promote_to_write(sg_w);
TableRef t = group_w.add_table("table1");
t->add_column(type_Int, "int1");
t->add_empty_row(2);
TableRef t2 = group_w.add_table("table2");
t2->add_column(type_Int, "int_col");
t2->add_column_link(type_Link, "link", *t);
t2->add_empty_row();
t2->set_link(1, 0, 1);
t2->remove_column(0); // after this call LinkColumnBase::m_column_ndx was incorrect
t2->add_column(type_Int, "int_col2");
// The stale backlink index would still be "1" which is now an integer column in t2
// so the assertion in Spec::get_opposite_link_table() would fail when removing a link
t->remove(1);
CHECK_EQUAL(t->size(), 1);
CHECK_EQUAL(t2->get_link(0, 0), realm::npos); // no link
}
TEST(Table_ColumnsSupportStringIndex)
{
std::vector<DataType> all_types{type_Int, type_Bool, type_Float, type_Double, type_String,
type_Binary, type_OldDateTime, type_Timestamp, type_Table, type_Mixed};
std::vector<DataType> supports_index{type_Int, type_Bool, type_String, type_OldDateTime, type_Timestamp};
Group g; // type_Link must be part of a group
TableRef t = g.add_table("t1");
for (auto it = all_types.begin(); it != all_types.end(); ++it) {
t->add_column(*it, "");
ColumnBase& col = _impl::TableFriend::get_column(*t, 0);
bool does_support_index = col.supports_search_index();
auto found_pos = std::find(supports_index.begin(), supports_index.end(), *it);
CHECK_EQUAL(does_support_index, (found_pos != supports_index.end()));
CHECK_EQUAL(does_support_index, (col.create_search_index() != nullptr));
CHECK_EQUAL(does_support_index, col.has_search_index());
col.destroy_search_index();
CHECK(!col.has_search_index());
if (does_support_index) {
t->add_search_index(0);
}
else {
CHECK_LOGIC_ERROR(t->add_search_index(0), LogicError::illegal_combination);
}
CHECK_EQUAL(does_support_index, t->has_search_index(0));
t->remove_column(0);
}
// Check type_Link
t->add_column_link(type_Link, "", *t);
ColumnBase& link_col = _impl::TableFriend::get_column(*t, 0);
CHECK(!link_col.supports_search_index());
CHECK(link_col.create_search_index() == nullptr);
CHECK(!link_col.has_search_index());
CHECK_LOGIC_ERROR(t->add_search_index(0), LogicError::illegal_combination);
t->remove_column(0);
// Check type_LinkList
t->add_column_link(type_LinkList, "", *t);
ColumnBase& linklist_col = _impl::TableFriend::get_column(*t, 0);
CHECK(!linklist_col.supports_search_index());
CHECK(linklist_col.create_search_index() == nullptr);
CHECK(!linklist_col.has_search_index());
CHECK_LOGIC_ERROR(t->add_search_index(0), LogicError::illegal_combination);
t->remove_column(0);
// Check StringEnum
t->add_column(type_String, "");
bool force = true;
t->optimize(force);
ColumnBase& enum_col = _impl::TableFriend::get_column(*t, 0);
CHECK(enum_col.supports_search_index());
CHECK(enum_col.create_search_index() != nullptr);
CHECK(enum_col.has_search_index());
enum_col.destroy_search_index();
CHECK(!enum_col.has_search_index());
t->add_search_index(0);
CHECK(enum_col.has_search_index());
t->remove_column(0);
}
TEST(Table_addRowsToTableWithNoColumns)
{
Group g; // type_Link must be part of a group
TableRef t = g.add_table("t");
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
CHECK_LOGIC_ERROR(t->insert_empty_row(0), LogicError::table_has_no_columns);
CHECK_EQUAL(t->size(), 0);
t->add_column(type_String, "str_col");
t->add_empty_row(1);
CHECK_EQUAL(t->size(), 1);
t->add_search_index(0);
t->insert_empty_row(0);
CHECK_EQUAL(t->size(), 2);
t->remove_column(0);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
// Can add rows to a table with backlinks
TableRef u = g.add_table("u");
u->add_column_link(type_Link, "link from u to t", *t);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
t->add_empty_row(1);
CHECK_EQUAL(t->size(), 1);
u->remove_column(0);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
// Do the exact same as above but with LinkLists
u->add_column_link(type_LinkList, "link list from u to t", *t);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
t->add_empty_row(1);
CHECK_EQUAL(t->size(), 1);
u->remove_column(0);
CHECK_EQUAL(u->size(), 0);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(t->add_empty_row(1), LogicError::table_has_no_columns);
// Check that links are nulled when connected table is cleared
u->add_column_link(type_Link, "link from u to t", *t);
u->add_empty_row(1);
CHECK_EQUAL(u->size(), 1);
CHECK_EQUAL(t->size(), 0);
CHECK_LOGIC_ERROR(u->set_link(0, 0, 0), LogicError::target_row_index_out_of_range);
CHECK(u->is_null_link(0, 0));
CHECK_EQUAL(t->size(), 0);
t->add_empty_row();
u->set_link(0, 0, 0);
CHECK_EQUAL(u->get_link(0, 0), 0);
CHECK(!u->is_null_link(0, 0));
CHECK_EQUAL(t->size(), 1);
t->add_column(type_Int, "int column");
CHECK_EQUAL(t->size(), 1);
t->remove_column(0);
CHECK_EQUAL(t->size(), 0);
CHECK_EQUAL(u->size(), 1);
CHECK(u->is_null_link(0, 0));
}
TEST(Table_getVersionCounterAfterRowAccessor)
{
Table t;
size_t col_bool = t.add_column(type_Bool, "bool", true);
size_t col_int = t.add_column(type_Int, "int", true);
size_t col_string = t.add_column(type_String, "string", true);
size_t col_float = t.add_column(type_Float, "float", true);
size_t col_double = t.add_column(type_Double, "double", true);
size_t col_date = t.add_column(type_OldDateTime, "date", true);
size_t col_binary = t.add_column(type_Binary, "binary", true);
size_t col_timestamp = t.add_column(type_Timestamp, "timestamp", true);
t.add_empty_row(1);
int_fast64_t ver = t.get_version_counter();
int_fast64_t newVer;
auto check_ver_bump = [&]() {
newVer = t.get_version_counter();
CHECK_GREATER(newVer, ver);
ver = newVer;
};
t.set_bool(col_bool, 0, true);
check_ver_bump();
t.set_int(col_int, 0, 42);
check_ver_bump();
t.set_string(col_string, 0, "foo");
check_ver_bump();
t.set_float(col_float, 0, 0.42f);
check_ver_bump();
t.set_double(col_double, 0, 0.42);
check_ver_bump();
t.set_olddatetime(col_date, 0, 1234);
check_ver_bump();
t.set_binary(col_binary, 0, BinaryData("binary", 7));
check_ver_bump();
t.set_timestamp(col_timestamp, 0, Timestamp(777, 888));
check_ver_bump();
t.set_null(0, 0);
check_ver_bump();
}
// This test a bug where get_size_from_type_and_ref() returned off-by-one on nullable integer columns.
// It seems to be only invoked from Table::get_size_from_ref() which is fast static method that lets
// you find the size of a Table without having to create an instance of it. This seems to be only done
// on subtables, so the bug has not been triggered in public.
TEST_TYPES(Table_ColumnSizeFromRef, std::true_type, std::false_type)
{
constexpr bool nullable_toggle = TEST_TYPE::value;
Group g;
TableRef t = g.add_table("table");
t->add_column(type_Int, "int", nullable_toggle);
t->add_column(type_Bool, "bool", nullable_toggle);
t->add_column(type_String, "string", nullable_toggle);
t->add_column(type_Binary, "binary", nullable_toggle);
t->add_column(type_Double, "double");
t->add_column(type_Float, "float");
t->add_column(type_Mixed, "mixed");
t->add_column(type_Timestamp, "timestamp");
t->add_column_link(type_Link, "link", *t);
t->add_column_link(type_LinkList, "LinkList", *t);
auto check_column_sizes = [this, &t](size_t num_rows) {
t->clear();
t->add_empty_row(num_rows);
CHECK_EQUAL(t->size(), num_rows);
using tf = _impl::TableFriend;
Spec& t_spec = tf::get_spec(*t);
size_t actual_num_cols = t_spec.get_column_count();
for (size_t col_ndx = 0; col_ndx < actual_num_cols; ++col_ndx) {
ColumnType col_type = t_spec.get_column_type(col_ndx);
ColumnBase& base = tf::get_column(*t, col_ndx);
ref_type col_ref = base.get_ref();
bool nullable = (t_spec.get_column_attr(col_ndx) & col_attr_Nullable) == col_attr_Nullable;
size_t col_size = ColumnBase::get_size_from_type_and_ref(col_type, col_ref, base.get_alloc(), nullable);
CHECK_EQUAL(col_size, num_rows);
}
};
// Test leafs
check_column_sizes(REALM_MAX_BPNODE_SIZE - 1);
// Test empty
check_column_sizes(0);
// Test internal nodes
check_column_sizes(REALM_MAX_BPNODE_SIZE + 1);
// Test on boundary for good measure
check_column_sizes(REALM_MAX_BPNODE_SIZE);
// Try with more levels in the tree
check_column_sizes(10 * REALM_MAX_BPNODE_SIZE);
}
#endif // TEST_TABLE
|
/*
Zipios++ - a small C++ library that provides easy access to .zip files.
Copyright (C) 2000-2015 Thomas Sondergaard
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/** \file
*
* Zipios++ unit tests verify the dostime.c/h private implementations.
*
* \warning
* This directly accesses dostime.h which is a private header file.
*/
#include "catch_tests.hpp"
#include "src/dostime.h"
#include <fstream>
#include <sys/stat.h>
#include <unistd.h>
TEST_CASE("Unix to DOS time conversions and vice versa", "[dostime]")
{
REQUIRE(mindostime() == dostime(1980, 1, 1, 0, 0, 0));
REQUIRE(maxdostime() == dostime(2107, 12, 31, 23, 59, 59));
if(sizeof(time_t) < sizeof(uint64_t))
{
std::cerr << "warning: Unix to DOS time conversion is ignored on platform with a 32 bit time_t definition." << std::endl;
return;
}
time_t const clock = time(NULL);
struct tm *mm_time = localtime(&clock);
mm_time->tm_isdst = -1; /* let mktime() determine if DST is in effect */
mm_time->tm_sec = 0; // min = Jan 1, 1980 at 00:00:00
mm_time->tm_min = 0;
mm_time->tm_hour = 0;
mm_time->tm_mday = 1;
mm_time->tm_mon = 0;
mm_time->tm_year = 80;
time_t const minimum_unix = mktime(mm_time);
mm_time->tm_isdst = -1; /* let mktime() determine if DST is in effect */
mm_time->tm_sec = 59; // max = Dec 3, 2107 at 23:59:59
mm_time->tm_min = 59;
mm_time->tm_hour = 23;
mm_time->tm_mday = 31;
mm_time->tm_mon = 11;
mm_time->tm_year = 207;
time_t const maximum_unix = mktime(mm_time);
// make sure the minimum limit is checked properly
for(time_t t(minimum_unix - 20); t <= minimum_unix + 20; ++t)
{
time_t et((t + 1) & ~1);
dostime_t const d(unix2dostime(t));
time_t const u(dos2unixtime(d));
if(et < minimum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else
{
// TODO: add necessary code to verify DST?
long long int const diff(llabs(u - et));
bool const valid(diff == 0 || diff == 3600);
REQUIRE(valid);
}
}
// make sure the maximum limit is checked properly
for(time_t t(maximum_unix - 20); t <= maximum_unix + 20; ++t)
{
time_t et((t + 1) & ~1);
dostime_t const d(unix2dostime(t));
time_t const u(dos2unixtime(d));
if(et > maximum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else
{
// TODO: add necessary code to verify DST?
long long int const diff(llabs(u - et));
bool const valid(diff == 0 || diff == 3600);
REQUIRE(valid);
}
}
// we verified that time_t is at least a 64 bit type
for(time_t t(0); t <= 0x104000000; t += rand() & 0xFFFF)
{
time_t et((t + 1) & ~1);
dostime_t const d(unix2dostime(t));
time_t const u(dos2unixtime(d));
if(et < minimum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else if(et > maximum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else
{
// TODO: add necessary code to verify DST?
long long int const diff(llabs(u - et));
bool const valid(diff == 0 || diff == 3600);
REQUIRE(valid);
}
}
}
// vim: ts=4 sw=4 et
time_t is 32 bits on OpenSolaris x86 so we need to use a special loop for that purpose.
/*
Zipios++ - a small C++ library that provides easy access to .zip files.
Copyright (C) 2000-2015 Thomas Sondergaard
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/** \file
*
* Zipios++ unit tests verify the dostime.c/h private implementations.
*
* \warning
* This directly accesses dostime.h which is a private header file.
*/
#include "catch_tests.hpp"
#include "src/dostime.h"
#include <fstream>
#include <sys/stat.h>
#include <unistd.h>
TEST_CASE("Unix to DOS time conversions and vice versa", "[dostime]")
{
REQUIRE(mindostime() == dostime(1980, 1, 1, 0, 0, 0));
REQUIRE(maxdostime() == dostime(2107, 12, 31, 23, 59, 59));
if(sizeof(time_t) < sizeof(uint64_t))
{
std::cerr << "warning: Unix to DOS time conversion is ignored on platform with a 32 bit time_t definition." << std::endl;
return;
}
time_t const clock = time(NULL);
struct tm *mm_time = localtime(&clock);
mm_time->tm_isdst = -1; /* let mktime() determine if DST is in effect */
mm_time->tm_sec = 0; // min = Jan 1, 1980 at 00:00:00
mm_time->tm_min = 0;
mm_time->tm_hour = 0;
mm_time->tm_mday = 1;
mm_time->tm_mon = 0;
mm_time->tm_year = 80;
time_t const minimum_unix = mktime(mm_time);
mm_time->tm_isdst = -1; /* let mktime() determine if DST is in effect */
mm_time->tm_sec = 59; // max = Dec 3, 2107 at 23:59:59
mm_time->tm_min = 59;
mm_time->tm_hour = 23;
mm_time->tm_mday = 31;
mm_time->tm_mon = 11;
mm_time->tm_year = 207;
time_t const maximum_unix = mktime(mm_time);
// make sure the minimum limit is checked properly
for(time_t t(minimum_unix - 20); t <= minimum_unix + 20; ++t)
{
time_t et((t + 1) & ~1);
dostime_t const d(unix2dostime(t));
time_t const u(dos2unixtime(d));
if(et < minimum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else
{
// TODO: add necessary code to verify DST?
long long int const diff(llabs(u - et));
bool const valid(diff == 0 || diff == 3600);
REQUIRE(valid);
}
}
// make sure the maximum limit is checked properly
for(time_t t(maximum_unix - 20); t <= maximum_unix + 20; ++t)
{
time_t et((t + 1) & ~1);
dostime_t const d(unix2dostime(t));
time_t const u(dos2unixtime(d));
if(et > maximum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else
{
// TODO: add necessary code to verify DST?
long long int const diff(llabs(u - et));
bool const valid(diff == 0 || diff == 3600);
REQUIRE(valid);
}
}
// we verified that time_t is at least a 64 bit type
#if defined(_ILP32)
for(time_t t(0); t <= 0x7FFFFFFF; t += rand() & 0x7FFF)
#else
for(time_t t(0); t <= 0x104000000; t += rand() & 0xFFFF)
#endif
{
time_t et((t + 1) & ~1);
dostime_t const d(unix2dostime(t));
time_t const u(dos2unixtime(d));
if(et < minimum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else if(et > maximum_unix)
{
REQUIRE(d == 0);
REQUIRE(u == -1);
}
else
{
// TODO: add necessary code to verify DST?
long long int const diff(llabs(u - et));
bool const valid(diff == 0 || diff == 3600);
REQUIRE(valid);
}
}
}
// vim: ts=4 sw=4 et
|
// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/precompiler.h"
#include "vm/aot_optimizer.h"
#include "vm/assembler.h"
#include "vm/ast_printer.h"
#include "vm/branch_optimizer.h"
#include "vm/cha.h"
#include "vm/code_generator.h"
#include "vm/code_patcher.h"
#include "vm/compiler.h"
#include "vm/constant_propagator.h"
#include "vm/dart_entry.h"
#include "vm/disassembler.h"
#include "vm/exceptions.h"
#include "vm/flags.h"
#include "vm/flow_graph.h"
#include "vm/flow_graph_allocator.h"
#include "vm/flow_graph_builder.h"
#include "vm/flow_graph_compiler.h"
#include "vm/flow_graph_inliner.h"
#include "vm/flow_graph_range_analysis.h"
#include "vm/flow_graph_type_propagator.h"
#include "vm/hash_table.h"
#include "vm/il_printer.h"
#include "vm/isolate.h"
#include "vm/log.h"
#include "vm/longjump.h"
#include "vm/object.h"
#include "vm/object_store.h"
#include "vm/os.h"
#include "vm/parser.h"
#include "vm/redundancy_elimination.h"
#include "vm/regexp_assembler.h"
#include "vm/regexp_parser.h"
#include "vm/resolver.h"
#include "vm/symbols.h"
#include "vm/tags.h"
#include "vm/timer.h"
namespace dart {
#define T (thread())
#define I (isolate())
#define Z (zone())
DEFINE_FLAG(bool, print_unique_targets, false, "Print unique dynaic targets");
DEFINE_FLAG(bool, trace_precompiler, false, "Trace precompiler.");
DEFINE_FLAG(int, max_speculative_inlining_attempts, 1,
"Max number of attempts with speculative inlining (precompilation only)");
DECLARE_FLAG(bool, allocation_sinking);
DECLARE_FLAG(bool, common_subexpression_elimination);
DECLARE_FLAG(bool, constant_propagation);
DECLARE_FLAG(bool, loop_invariant_code_motion);
DECLARE_FLAG(bool, print_flow_graph);
DECLARE_FLAG(bool, print_flow_graph_optimized);
DECLARE_FLAG(bool, range_analysis);
DECLARE_FLAG(bool, trace_compiler);
DECLARE_FLAG(bool, trace_optimizing_compiler);
DECLARE_FLAG(bool, trace_bailout);
DECLARE_FLAG(bool, use_inlining);
DECLARE_FLAG(bool, verify_compiler);
DECLARE_FLAG(bool, huge_method_cutoff_in_code_size);
DECLARE_FLAG(bool, trace_failed_optimization_attempts);
DECLARE_FLAG(bool, trace_inlining_intervals);
DECLARE_FLAG(bool, trace_irregexp);
#ifdef DART_PRECOMPILER
class PrecompileParsedFunctionHelper : public ValueObject {
public:
PrecompileParsedFunctionHelper(ParsedFunction* parsed_function,
bool optimized)
: parsed_function_(parsed_function),
optimized_(optimized),
thread_(Thread::Current()) {
}
bool Compile(CompilationPipeline* pipeline);
private:
ParsedFunction* parsed_function() const { return parsed_function_; }
bool optimized() const { return optimized_; }
Thread* thread() const { return thread_; }
Isolate* isolate() const { return thread_->isolate(); }
void FinalizeCompilation(Assembler* assembler,
FlowGraphCompiler* graph_compiler,
FlowGraph* flow_graph);
ParsedFunction* parsed_function_;
const bool optimized_;
Thread* const thread_;
DISALLOW_COPY_AND_ASSIGN(PrecompileParsedFunctionHelper);
};
static void Jump(const Error& error) {
Thread::Current()->long_jump_base()->Jump(1, error);
}
RawError* Precompiler::CompileAll(
Dart_QualifiedFunctionName embedder_entry_points[],
bool reset_fields) {
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
Precompiler precompiler(Thread::Current(), reset_fields);
precompiler.DoCompileAll(embedder_entry_points);
return Error::null();
} else {
Thread* thread = Thread::Current();
const Error& error = Error::Handle(thread->sticky_error());
thread->clear_sticky_error();
return error.raw();
}
}
Precompiler::Precompiler(Thread* thread, bool reset_fields) :
thread_(thread),
zone_(NULL),
isolate_(thread->isolate()),
reset_fields_(reset_fields),
changed_(false),
function_count_(0),
class_count_(0),
selector_count_(0),
dropped_function_count_(0),
dropped_field_count_(0),
dropped_class_count_(0),
dropped_typearg_count_(0),
dropped_type_count_(0),
dropped_library_count_(0),
libraries_(GrowableObjectArray::Handle(I->object_store()->libraries())),
pending_functions_(
GrowableObjectArray::Handle(GrowableObjectArray::New())),
sent_selectors_(),
enqueued_functions_(),
fields_to_retain_(),
classes_to_retain_(),
typeargs_to_retain_(),
types_to_retain_(),
error_(Error::Handle()) {
}
void Precompiler::DoCompileAll(
Dart_QualifiedFunctionName embedder_entry_points[]) {
ASSERT(I->compilation_allowed());
{
StackZone stack_zone(T);
zone_ = stack_zone.GetZone();
// Make sure class hierarchy is stable before compilation so that CHA
// can be used. Also ensures lookup of entry points won't miss functions
// because their class hasn't been finalized yet.
FinalizeAllClasses();
const intptr_t kPrecompilerRounds = 1;
for (intptr_t round = 0; round < kPrecompilerRounds; round++) {
if (FLAG_trace_precompiler) {
THR_Print("Precompiler round %" Pd "\n", round);
}
if (round > 0) {
ResetPrecompilerState();
}
// TODO(rmacnak): We should be able to do a more thorough job and drop
// some
// - implicit static closures
// - field initializers
// - invoke-field-dispatchers
// - method-extractors
// that are needed in early iterations but optimized away in later
// iterations.
ClearAllCode();
CollectDynamicFunctionNames();
// Start with the allocations and invocations that happen from C++.
AddRoots(embedder_entry_points);
// Compile newly found targets and add their callees until we reach a
// fixed point.
Iterate();
}
I->set_compilation_allowed(false);
DropFunctions();
DropFields();
TraceTypesFromRetainedClasses();
DropTypes();
DropTypeArguments();
DropClasses();
DropLibraries();
BindStaticCalls();
DedupStackmaps();
DedupStackmapLists();
if (FLAG_dedup_instructions) {
// Reduces binary size but obfuscates profiler results.
DedupInstructions();
}
I->object_store()->set_compile_time_constants(Array::null_array());
I->object_store()->set_unique_dynamic_targets(Array::null_array());
zone_ = NULL;
}
intptr_t dropped_symbols_count = Symbols::Compact(I);
if (FLAG_trace_precompiler) {
THR_Print("Precompiled %" Pd " functions,", function_count_);
THR_Print(" %" Pd " dynamic types,", class_count_);
THR_Print(" %" Pd " dynamic selectors.\n", selector_count_);
THR_Print("Dropped %" Pd " functions,", dropped_function_count_);
THR_Print(" %" Pd " fields,", dropped_field_count_);
THR_Print(" %" Pd " symbols,", dropped_symbols_count);
THR_Print(" %" Pd " types,", dropped_type_count_);
THR_Print(" %" Pd " type arguments,", dropped_typearg_count_);
THR_Print(" %" Pd " classes,", dropped_class_count_);
THR_Print(" %" Pd " libraries.\n", dropped_library_count_);
}
}
void Precompiler::ClearAllCode() {
class ClearCodeFunctionVisitor : public FunctionVisitor {
void VisitFunction(const Function& function) {
function.ClearCode();
function.ClearICDataArray();
}
};
ClearCodeFunctionVisitor visitor;
VisitFunctions(&visitor);
}
void Precompiler::AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]) {
// Note that <rootlibrary>.main is not a root. The appropriate main will be
// discovered through _getMainClosure.
AddSelector(Symbols::NoSuchMethod());
AddSelector(Symbols::Call()); // For speed, not correctness.
// Allocated from C++.
Class& cls = Class::Handle(Z);
for (intptr_t cid = kInstanceCid; cid < kNumPredefinedCids; cid++) {
ASSERT(isolate()->class_table()->IsValidIndex(cid));
if (!isolate()->class_table()->HasValidClassAt(cid)) {
continue;
}
if ((cid == kDynamicCid) ||
(cid == kVoidCid) ||
(cid == kFreeListElement)) {
continue;
}
cls = isolate()->class_table()->At(cid);
AddInstantiatedClass(cls);
}
Dart_QualifiedFunctionName vm_entry_points[] = {
// Functions
{ "dart:async", "::", "_setScheduleImmediateClosure" },
{ "dart:core", "::", "_completeDeferredLoads" },
{ "dart:core", "AbstractClassInstantiationError",
"AbstractClassInstantiationError._create" },
{ "dart:core", "ArgumentError", "ArgumentError." },
{ "dart:core", "CyclicInitializationError",
"CyclicInitializationError." },
{ "dart:core", "FallThroughError", "FallThroughError._create" },
{ "dart:core", "FormatException", "FormatException." },
{ "dart:core", "NoSuchMethodError", "NoSuchMethodError._withType" },
{ "dart:core", "NullThrownError", "NullThrownError." },
{ "dart:core", "OutOfMemoryError", "OutOfMemoryError." },
{ "dart:core", "RangeError", "RangeError." },
{ "dart:core", "RangeError", "RangeError.range" },
{ "dart:core", "StackOverflowError", "StackOverflowError." },
{ "dart:core", "UnsupportedError", "UnsupportedError." },
{ "dart:core", "_AssertionError", "_AssertionError._create" },
{ "dart:core", "_CastError", "_CastError._create" },
{ "dart:core", "_InternalError", "_InternalError." },
{ "dart:core", "_InvocationMirror", "_allocateInvocationMirror" },
{ "dart:core", "_TypeError", "_TypeError._create" },
{ "dart:isolate", "IsolateSpawnException", "IsolateSpawnException." },
{ "dart:isolate", "::", "_getIsolateScheduleImmediateClosure" },
{ "dart:isolate", "::", "_setupHooks" },
{ "dart:isolate", "::", "_startMainIsolate" },
{ "dart:isolate", "_RawReceivePortImpl", "_handleMessage" },
{ "dart:isolate", "_RawReceivePortImpl", "_lookupHandler" },
{ "dart:isolate", "_SendPortImpl", "send" },
{ "dart:typed_data", "ByteData", "ByteData." },
{ "dart:typed_data", "ByteData", "ByteData._view" },
{ "dart:typed_data", "_ByteBuffer", "_ByteBuffer._New" },
{ "dart:_vmservice", "::", "_registerIsolate" },
{ "dart:_vmservice", "::", "boot" },
{ "dart:developer", "Metrics", "_printMetrics" },
// Fields
{ "dart:core", "Error", "_stackTrace" },
{ "dart:math", "_Random", "_state" },
{ NULL, NULL, NULL } // Must be terminated with NULL entries.
};
AddEntryPoints(vm_entry_points);
AddEntryPoints(embedder_entry_points);
}
void Precompiler::AddEntryPoints(Dart_QualifiedFunctionName entry_points[]) {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Function& func = Function::Handle(Z);
Field& field = Field::Handle(Z);
String& library_uri = String::Handle(Z);
String& class_name = String::Handle(Z);
String& function_name = String::Handle(Z);
for (intptr_t i = 0; entry_points[i].library_uri != NULL; i++) {
library_uri = Symbols::New(entry_points[i].library_uri);
class_name = Symbols::New(entry_points[i].class_name);
function_name = Symbols::New(entry_points[i].function_name);
lib = Library::LookupLibrary(library_uri);
if (lib.IsNull()) {
String& msg = String::Handle(Z, String::NewFormatted(
"Cannot find entry point %s\n", entry_points[i].library_uri));
Jump(Error::Handle(Z, ApiError::New(msg)));
UNREACHABLE();
}
if (class_name.raw() == Symbols::TopLevel().raw()) {
if (Library::IsPrivate(function_name)) {
function_name = lib.PrivateName(function_name);
}
func = lib.LookupLocalFunction(function_name);
field = lib.LookupLocalField(function_name);
} else {
if (Library::IsPrivate(class_name)) {
class_name = lib.PrivateName(class_name);
}
cls = lib.LookupLocalClass(class_name);
if (cls.IsNull()) {
String& msg = String::Handle(Z, String::NewFormatted(
"Cannot find entry point %s %s\n",
entry_points[i].library_uri,
entry_points[i].class_name));
Jump(Error::Handle(Z, ApiError::New(msg)));
UNREACHABLE();
}
ASSERT(!cls.IsNull());
func = cls.LookupFunctionAllowPrivate(function_name);
field = cls.LookupField(function_name);
}
if (func.IsNull() && field.IsNull()) {
String& msg = String::Handle(Z, String::NewFormatted(
"Cannot find entry point %s %s %s\n",
entry_points[i].library_uri,
entry_points[i].class_name,
entry_points[i].function_name));
Jump(Error::Handle(Z, ApiError::New(msg)));
UNREACHABLE();
}
if (!func.IsNull()) {
AddFunction(func);
if (func.IsGenerativeConstructor()) {
// Allocation stubs are referenced from the call site of the
// constructor, not in the constructor itself. So compiling the
// constructor isn't enough for us to discover the class is
// instantiated if the class isn't otherwise instantiated from Dart
// code and only instantiated from C++.
AddInstantiatedClass(cls);
}
}
if (!field.IsNull()) {
AddField(field);
}
}
}
void Precompiler::Iterate() {
Function& function = Function::Handle(Z);
while (changed_) {
changed_ = false;
while (pending_functions_.Length() > 0) {
function ^= pending_functions_.RemoveLast();
ProcessFunction(function);
}
CheckForNewDynamicFunctions();
}
}
void Precompiler::ProcessFunction(const Function& function) {
if (!function.HasCode()) {
function_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompiling %" Pd " %s (%s, %s)\n",
function_count_,
function.ToLibNamePrefixedQualifiedCString(),
function.token_pos().ToCString(),
Function::KindToCString(function.kind()));
}
ASSERT(!function.is_abstract());
ASSERT(!function.IsRedirectingFactory());
error_ = CompileFunction(thread_, function);
if (!error_.IsNull()) {
Jump(error_);
}
// Used in the JIT to save type-feedback across compilations.
function.ClearICDataArray();
} else {
if (FLAG_trace_precompiler) {
// This function was compiled from somewhere other than Precompiler,
// such as const constructors compiled by the parser.
THR_Print("Already has code: %s (%s, %s)\n",
function.ToLibNamePrefixedQualifiedCString(),
function.token_pos().ToCString(),
Function::KindToCString(function.kind()));
}
}
ASSERT(function.HasCode());
AddCalleesOf(function);
}
void Precompiler::AddCalleesOf(const Function& function) {
ASSERT(function.HasCode());
const Code& code = Code::Handle(Z, function.CurrentCode());
const Array& table = Array::Handle(Z, code.static_calls_target_table());
Object& entry = Object::Handle(Z);
Function& target = Function::Handle(Z);
for (intptr_t i = 0; i < table.Length(); i++) {
entry = table.At(i);
if (entry.IsFunction()) {
target ^= entry.raw();
AddFunction(target);
}
}
#if defined(TARGET_ARCH_IA32)
FATAL("Callee scanning unimplemented for IA32");
#endif
const ObjectPool& pool = ObjectPool::Handle(Z, code.GetObjectPool());
ICData& call_site = ICData::Handle(Z);
MegamorphicCache& cache = MegamorphicCache::Handle(Z);
String& selector = String::Handle(Z);
Field& field = Field::Handle(Z);
Class& cls = Class::Handle(Z);
Instance& instance = Instance::Handle(Z);
Code& target_code = Code::Handle(Z);
for (intptr_t i = 0; i < pool.Length(); i++) {
if (pool.InfoAt(i) == ObjectPool::kTaggedObject) {
entry = pool.ObjectAt(i);
if (entry.IsICData()) {
call_site ^= entry.raw();
for (intptr_t j = 0; j < call_site.NumberOfChecks(); j++) {
target = call_site.GetTargetAt(j);
AddFunction(target);
if (!target.is_static()) {
// Super call (should not enqueue selector) or dynamic call with a
// CHA prediction (should enqueue selector).
selector = call_site.target_name();
AddSelector(selector);
}
}
if (call_site.NumberOfChecks() == 0) {
// A dynamic call.
selector = call_site.target_name();
AddSelector(selector);
if (selector.raw() == Symbols::Call().raw()) {
// Potential closure call.
AddClosureCall(call_site);
}
}
} else if (entry.IsMegamorphicCache()) {
// A dynamic call.
cache ^= entry.raw();
selector = cache.target_name();
AddSelector(selector);
} else if (entry.IsField()) {
// Potential need for field initializer.
field ^= entry.raw();
AddField(field);
} else if (entry.IsInstance()) {
// Const object, literal or args descriptor.
instance ^= entry.raw();
if (entry.IsAbstractType()) {
AddType(AbstractType::Cast(entry));
} else {
AddConstObject(instance);
}
} else if (entry.IsFunction()) {
// Local closure function.
target ^= entry.raw();
AddFunction(target);
} else if (entry.IsCode()) {
target_code ^= entry.raw();
if (target_code.IsAllocationStubCode()) {
cls ^= target_code.owner();
AddInstantiatedClass(cls);
}
} else if (entry.IsTypeArguments()) {
AddTypeArguments(TypeArguments::Cast(entry));
}
}
}
}
void Precompiler::AddTypesOf(const Class& cls) {
if (cls.IsNull()) return;
if (classes_to_retain_.Lookup(&cls) != NULL) return;
classes_to_retain_.Insert(&Class::ZoneHandle(Z, cls.raw()));
Array& interfaces = Array::Handle(Z, cls.interfaces());
AbstractType& type = AbstractType::Handle(Z);
for (intptr_t i = 0; i < interfaces.Length(); i++) {
type ^= interfaces.At(i);
AddType(type);
}
AddTypeArguments(TypeArguments::Handle(Z, cls.type_parameters()));
type = cls.super_type();
AddType(type);
type = cls.mixin();
AddType(type);
if (cls.IsTypedefClass()) {
AddTypesOf(Function::Handle(Z, cls.signature_function()));
}
}
void Precompiler::AddTypesOf(const Function& function) {
AbstractType& type = AbstractType::Handle(Z);
type = function.result_type();
AddType(type);
for (intptr_t i = 0; i < function.NumParameters(); i++) {
type = function.ParameterTypeAt(i);
AddType(type);
}
}
void Precompiler::AddType(const AbstractType& abstype) {
if (abstype.IsNull()) return;
if (types_to_retain_.Lookup(&abstype) != NULL) return;
types_to_retain_.Insert(&AbstractType::ZoneHandle(Z, abstype.raw()));
if (abstype.IsType()) {
const Type& type = Type::Cast(abstype);
const Class& cls = Class::Handle(Z, type.type_class());
AddTypesOf(cls);
const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
AddTypeArguments(vector);
} else if (abstype.IsFunctionType()) {
const FunctionType& func_type = FunctionType::Cast(abstype);
const Class& cls = Class::Handle(Z, func_type.scope_class());
AddTypesOf(cls);
const Function& func = Function::Handle(Z, func_type.signature());
AddTypesOf(func);
const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
AddTypeArguments(vector);
} else if (abstype.IsBoundedType()) {
AbstractType& type = AbstractType::Handle(Z);
type = BoundedType::Cast(abstype).type();
AddType(type);
type = BoundedType::Cast(abstype).bound();
AddType(type);
} else if (abstype.IsTypeRef()) {
AbstractType& type = AbstractType::Handle(Z);
type = TypeRef::Cast(abstype).type();
AddType(type);
}
}
void Precompiler::AddTypeArguments(const TypeArguments& args) {
if (args.IsNull()) return;
if (typeargs_to_retain_.Lookup(&args) != NULL) return;
typeargs_to_retain_.Insert(&TypeArguments::ZoneHandle(Z, args.raw()));
AbstractType& arg = AbstractType::Handle(Z);
for (intptr_t i = 0; i < args.Length(); i++) {
arg = args.TypeAt(i);
AddType(arg);
}
}
void Precompiler::AddConstObject(const Instance& instance) {
const Class& cls = Class::Handle(Z, instance.clazz());
AddInstantiatedClass(cls);
if (instance.IsClosure()) {
// An implicit static closure.
const Function& func =
Function::Handle(Z, Closure::Cast(instance).function());
ASSERT(func.is_static());
AddFunction(func);
AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
return;
}
// Can't ask immediate objects if they're canoncial.
if (instance.IsSmi()) return;
// Some Instances in the ObjectPool aren't const objects, such as
// argument descriptors.
if (!instance.IsCanonical()) return;
if (cls.NumTypeArguments() > 0) {
AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
}
class ConstObjectVisitor : public ObjectPointerVisitor {
public:
ConstObjectVisitor(Precompiler* precompiler, Isolate* isolate) :
ObjectPointerVisitor(isolate),
precompiler_(precompiler),
subinstance_(Object::Handle()) {}
virtual void VisitPointers(RawObject** first, RawObject** last) {
for (RawObject** current = first; current <= last; current++) {
subinstance_ = *current;
if (subinstance_.IsInstance()) {
precompiler_->AddConstObject(Instance::Cast(subinstance_));
}
}
subinstance_ = Object::null();
}
private:
Precompiler* precompiler_;
Object& subinstance_;
};
ConstObjectVisitor visitor(this, I);
instance.raw()->VisitPointers(&visitor);
}
void Precompiler::AddClosureCall(const ICData& call_site) {
const Array& arguments_descriptor =
Array::Handle(Z, call_site.arguments_descriptor());
const Class& cache_class =
Class::Handle(Z, I->object_store()->closure_class());
const Function& dispatcher = Function::Handle(Z,
cache_class.GetInvocationDispatcher(Symbols::Call(),
arguments_descriptor,
RawFunction::kInvokeFieldDispatcher,
true /* create_if_absent */));
AddFunction(dispatcher);
}
void Precompiler::AddField(const Field& field) {
fields_to_retain_.Insert(&Field::ZoneHandle(Z, field.raw()));
if (field.is_static()) {
const Object& value = Object::Handle(Z, field.StaticValue());
if (value.IsInstance()) {
AddConstObject(Instance::Cast(value));
}
if (field.has_initializer()) {
// Should not be in the middle of initialization while precompiling.
ASSERT(value.raw() != Object::transition_sentinel().raw());
const bool is_initialized = value.raw() != Object::sentinel().raw();
if (is_initialized && !reset_fields_) return;
if (!field.HasPrecompiledInitializer()) {
if (FLAG_trace_precompiler) {
THR_Print("Precompiling initializer for %s\n", field.ToCString());
}
ASSERT(!Dart::IsRunningPrecompiledCode());
field.SetStaticValue(Instance::Handle(field.SavedInitialStaticValue()));
const Function& initializer =
Function::Handle(CompileStaticInitializer(field));
if (!initializer.IsNull()) {
field.SetPrecompiledInitializer(initializer);
}
}
const Function& function =
Function::Handle(Z, field.PrecompiledInitializer());
AddCalleesOf(function);
}
}
}
RawFunction* Precompiler::CompileStaticInitializer(const Field& field) {
ASSERT(field.is_static());
if (field.HasPrecompiledInitializer()) {
// TODO(rmacnak): Investigate why this happens for _enum_names.
THR_Print("Warning: Ignoring repeated request for initializer for %s\n",
field.ToCString());
return Function::null();
}
Thread* thread = Thread::Current();
StackZone zone(thread);
ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
parsed_function->AllocateVariables();
// Non-optimized code generator.
DartCompilationPipeline pipeline;
PrecompileParsedFunctionHelper helper(parsed_function,
/* optimized = */ false);
helper.Compile(&pipeline);
return parsed_function->function().raw();
}
RawObject* Precompiler::EvaluateStaticInitializer(const Field& field) {
ASSERT(field.is_static());
// The VM sets the field's value to transiton_sentinel prior to
// evaluating the initializer value.
ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
// Under precompilation, the initializer may have already been compiled, in
// which case use it. Under lazy compilation or early in precompilation, the
// initializer has not yet been created, so create it now, but don't bother
// remembering it because it won't be used again.
Function& initializer = Function::Handle();
if (!field.HasPrecompiledInitializer()) {
initializer = CompileStaticInitializer(field);
Code::Handle(initializer.unoptimized_code()).set_var_descriptors(
Object::empty_var_descriptors());
} else {
initializer ^= field.PrecompiledInitializer();
}
// Invoke the function to evaluate the expression.
return DartEntry::InvokeFunction(initializer, Object::empty_array());
} else {
Thread* const thread = Thread::Current();
StackZone zone(thread);
const Error& error =
Error::Handle(thread->zone(), thread->sticky_error());
thread->clear_sticky_error();
return error.raw();
}
UNREACHABLE();
return Object::null();
}
RawObject* Precompiler::ExecuteOnce(SequenceNode* fragment) {
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
Thread* const thread = Thread::Current();
if (FLAG_support_ast_printer && FLAG_trace_compiler) {
THR_Print("compiling expression: ");
AstPrinter::PrintNode(fragment);
}
// Create a dummy function object for the code generator.
// The function needs to be associated with a named Class: the interface
// Function fits the bill.
const char* kEvalConst = "eval_const";
const Function& func = Function::ZoneHandle(Function::New(
String::Handle(Symbols::New(kEvalConst)),
RawFunction::kRegularFunction,
true, // static function
false, // not const function
false, // not abstract
false, // not external
false, // not native
Class::Handle(Type::Handle(Type::Function()).type_class()),
fragment->token_pos()));
func.set_result_type(Object::dynamic_type());
func.set_num_fixed_parameters(0);
func.SetNumOptionalParameters(0, true);
// Manually generated AST, do not recompile.
func.SetIsOptimizable(false);
func.set_is_debuggable(false);
// We compile the function here, even though InvokeFunction() below
// would compile func automatically. We are checking fewer invariants
// here.
ParsedFunction* parsed_function = new ParsedFunction(thread, func);
parsed_function->SetNodeSequence(fragment);
fragment->scope()->AddVariable(parsed_function->EnsureExpressionTemp());
fragment->scope()->AddVariable(
parsed_function->current_context_var());
parsed_function->AllocateVariables();
// Non-optimized code generator.
DartCompilationPipeline pipeline;
PrecompileParsedFunctionHelper helper(parsed_function,
/* optimized = */ false);
helper.Compile(&pipeline);
Code::Handle(func.unoptimized_code()).set_var_descriptors(
Object::empty_var_descriptors());
const Object& result = PassiveObject::Handle(
DartEntry::InvokeFunction(func, Object::empty_array()));
return result.raw();
} else {
Thread* const thread = Thread::Current();
const Object& result =
PassiveObject::Handle(thread->sticky_error());
thread->clear_sticky_error();
return result.raw();
}
UNREACHABLE();
return Object::null();
}
void Precompiler::AddFunction(const Function& function) {
if (enqueued_functions_.Lookup(&function) != NULL) return;
enqueued_functions_.Insert(&Function::ZoneHandle(Z, function.raw()));
pending_functions_.Add(function);
changed_ = true;
}
bool Precompiler::IsSent(const String& selector) {
if (selector.IsNull()) {
return false;
}
return sent_selectors_.Lookup(&selector) != NULL;
}
void Precompiler::AddSelector(const String& selector) {
ASSERT(!selector.IsNull());
if (!IsSent(selector)) {
sent_selectors_.Insert(&String::ZoneHandle(Z, selector.raw()));
selector_count_++;
changed_ = true;
if (FLAG_trace_precompiler) {
THR_Print("Enqueueing selector %" Pd " %s\n",
selector_count_,
selector.ToCString());
}
}
}
void Precompiler::AddInstantiatedClass(const Class& cls) {
if (cls.is_allocated()) return;
class_count_++;
cls.set_is_allocated(true);
error_ = cls.EnsureIsFinalized(T);
if (!error_.IsNull()) {
Jump(error_);
}
changed_ = true;
if (FLAG_trace_precompiler) {
THR_Print("Allocation %" Pd " %s\n", class_count_, cls.ToCString());
}
const Class& superclass = Class::Handle(cls.SuperClass());
if (!superclass.IsNull()) {
AddInstantiatedClass(superclass);
}
}
void Precompiler::CheckForNewDynamicFunctions() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Function& function = Function::Handle(Z);
Function& function2 = Function::Handle(Z);
String& selector = String::Handle(Z);
String& selector2 = String::Handle(Z);
String& selector3 = String::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (!cls.is_allocated()) continue;
functions = cls.functions();
for (intptr_t k = 0; k < functions.Length(); k++) {
function ^= functions.At(k);
if (function.is_static() || function.is_abstract()) continue;
// Don't bail out early if there is already code because we may discover
// the corresponding getter selector is sent in some later iteration.
// if (function.HasCode()) continue;
selector = function.name();
if (IsSent(selector)) {
AddFunction(function);
}
// Handle the implicit call type conversions.
if (Field::IsGetterName(selector)) {
selector2 = Field::NameFromGetter(selector);
selector3 = Symbols::Lookup(selector2);
if (IsSent(selector2)) {
// Call-through-getter.
// Function is get:foo and somewhere foo is called.
AddFunction(function);
}
selector3 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
selector2);
if (IsSent(selector3)) {
// Hash-closurization.
// Function is get:foo and somewhere get:#foo is called.
AddFunction(function);
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor get:#foo.
function2 = function.GetMethodExtractor(selector3);
AddFunction(function2);
}
} else if (Field::IsSetterName(selector)) {
selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
selector);
if (IsSent(selector2)) {
// Hash-closurization.
// Function is set:foo and somewhere get:#set:foo is called.
AddFunction(function);
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor get:#set:foo.
function2 = function.GetMethodExtractor(selector2);
AddFunction(function2);
}
} else if (function.kind() == RawFunction::kRegularFunction) {
selector2 = Field::LookupGetterSymbol(selector);
if (IsSent(selector2)) {
// Closurization.
// Function is foo and somewhere get:foo is called.
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor.
function2 = function.GetMethodExtractor(selector2);
AddFunction(function2);
}
selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
selector);
if (IsSent(selector2)) {
// Hash-closurization.
// Function is foo and somewhere get:#foo is called.
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor get:#foo
function2 = function.GetMethodExtractor(selector2);
AddFunction(function2);
}
}
}
}
}
}
class NameFunctionsTraits {
public:
static bool IsMatch(const Object& a, const Object& b) {
return a.IsString() && b.IsString() &&
String::Cast(a).Equals(String::Cast(b));
}
static uword Hash(const Object& obj) {
return String::Cast(obj).Hash();
}
static RawObject* NewKey(const String& str) {
return str.raw();
}
};
typedef UnorderedHashMap<NameFunctionsTraits> Table;
static void AddNameToFunctionsTable(Zone* zone,
Table* table,
const String& fname,
const Function& function) {
Array& farray = Array::Handle(zone);
farray ^= table->InsertNewOrGetValue(fname, Array::empty_array());
farray = Array::Grow(farray, farray.Length() + 1);
farray.SetAt(farray.Length() - 1, function);
table->UpdateValue(fname, farray);
}
void Precompiler::CollectDynamicFunctionNames() {
if (!FLAG_collect_dynamic_function_names) {
return;
}
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Function& function = Function::Handle(Z);
String& fname = String::Handle(Z);
Array& farray = Array::Handle(Z);
Table table(HashTables::New<Table>(100));
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
functions = cls.functions();
for (intptr_t j = 0; j < functions.Length(); j++) {
function ^= functions.At(j);
if (function.IsDynamicFunction()) {
fname = function.name();
if (function.IsSetterFunction() ||
function.IsImplicitSetterFunction()) {
AddNameToFunctionsTable(zone(), &table, fname, function);
} else if (function.IsGetterFunction() ||
function.IsImplicitGetterFunction()) {
// Enter both getter and non getter name.
AddNameToFunctionsTable(zone(), &table, fname, function);
fname = Field::NameFromGetter(fname);
AddNameToFunctionsTable(zone(), &table, fname, function);
} else {
// Regular function. Enter both getter and non getter name.
AddNameToFunctionsTable(zone(), &table, fname, function);
fname = Field::GetterName(fname);
AddNameToFunctionsTable(zone(), &table, fname, function);
}
}
}
}
}
// Locate all entries with one function only, and whose owner is neither
// subclassed nor implemented.
Table::Iterator iter(&table);
String& key = String::Handle(Z);
UniqueFunctionsSet functions_set(HashTables::New<UniqueFunctionsSet>(20));
while (iter.MoveNext()) {
intptr_t curr_key = iter.Current();
key ^= table.GetKey(curr_key);
farray ^= table.GetOrNull(key);
ASSERT(!farray.IsNull());
if (farray.Length() == 1) {
function ^= farray.At(0);
cls = function.Owner();
if (!CHA::IsImplemented(cls) && !CHA::HasSubclasses(cls)) {
functions_set.Insert(function);
}
}
}
if (FLAG_print_unique_targets) {
UniqueFunctionsSet::Iterator unique_iter(&functions_set);
while (unique_iter.MoveNext()) {
intptr_t curr_key = unique_iter.Current();
function ^= functions_set.GetKey(curr_key);
THR_Print("* %s\n", function.ToQualifiedCString());
}
THR_Print("%" Pd " of %" Pd " dynamic selectors are unique\n",
functions_set.NumOccupied(), table.NumOccupied());
}
isolate()->object_store()->set_unique_dynamic_targets(
functions_set.Release());
table.Release();
}
void Precompiler::GetUniqueDynamicTarget(Isolate* isolate,
const String& fname,
Object* function) {
UniqueFunctionsSet functions_set(
isolate->object_store()->unique_dynamic_targets());
ASSERT(fname.IsSymbol());
*function = functions_set.GetOrNull(fname);
ASSERT(functions_set.Release().raw() ==
isolate->object_store()->unique_dynamic_targets());
}
void Precompiler::DropFunctions() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Function& function = Function::Handle(Z);
Function& function2 = Function::Handle(Z);
GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
String& name = String::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
functions = cls.functions();
retained_functions = GrowableObjectArray::New();
for (intptr_t j = 0; j < functions.Length(); j++) {
function ^= functions.At(j);
bool retain = function.HasCode();
if (!retain && function.HasImplicitClosureFunction()) {
// It can happen that all uses of an implicit closure inline their
// target function, leaving the target function uncompiled. Keep
// the target function anyway so we can enumerate it to bind its
// static calls, etc.
function2 = function.ImplicitClosureFunction();
retain = function2.HasCode();
}
if (retain) {
retained_functions.Add(function);
function.DropUncompiledImplicitClosureFunction();
AddTypesOf(function);
} else {
bool top_level = cls.IsTopLevel();
if (top_level &&
(function.kind() != RawFunction::kImplicitStaticFinalGetter)) {
// Implicit static final getters are not added to the library
// dictionary in the first place.
name = function.DictionaryName();
bool removed = lib.RemoveObject(function, name);
ASSERT(removed);
}
dropped_function_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n",
function.ToLibNamePrefixedQualifiedCString());
}
}
}
if (retained_functions.Length() > 0) {
functions = Array::MakeArray(retained_functions);
cls.SetFunctions(functions);
} else {
cls.SetFunctions(Object::empty_array());
}
}
}
closures = isolate()->object_store()->closure_functions();
retained_functions = GrowableObjectArray::New();
for (intptr_t j = 0; j < closures.Length(); j++) {
function ^= closures.At(j);
bool retain = function.HasCode();
if (retain) {
retained_functions.Add(function);
AddTypesOf(function);
} else {
dropped_function_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n",
function.ToLibNamePrefixedQualifiedCString());
}
}
}
isolate()->object_store()->set_closure_functions(retained_functions);
}
void Precompiler::DropFields() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& fields = Array::Handle(Z);
Field& field = Field::Handle(Z);
GrowableObjectArray& retained_fields = GrowableObjectArray::Handle(Z);
String& name = String::Handle(Z);
AbstractType& type = AbstractType::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
fields = cls.fields();
retained_fields = GrowableObjectArray::New();
for (intptr_t j = 0; j < fields.Length(); j++) {
field ^= fields.At(j);
bool retain = fields_to_retain_.Lookup(&field) != NULL;
if (retain) {
retained_fields.Add(field);
type = field.type();
AddType(type);
} else {
bool top_level = cls.IsTopLevel();
if (top_level) {
name = field.DictionaryName();
bool removed = lib.RemoveObject(field, name);
ASSERT(removed);
}
dropped_field_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n",
field.ToCString());
}
}
}
if (retained_fields.Length() > 0) {
fields = Array::MakeArray(retained_fields);
cls.SetFields(fields);
} else {
cls.SetFields(Object::empty_array());
}
}
}
}
void Precompiler::DropTypes() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Object& obj = Object::Handle(Z);
Array& arr = Array::Handle(Z);
GrowableObjectArray& retained_types = GrowableObjectArray::Handle(Z);
AbstractType& type = AbstractType::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
obj = cls.canonical_types();
if (!obj.IsArray()) {
// Class only has one type, keep it.
} else {
// Class has many types.
arr ^= obj.raw();
retained_types = GrowableObjectArray::New();
// Always keep the first one.
ASSERT(arr.Length() >= 1);
obj = arr.At(0);
retained_types.Add(obj);
for (intptr_t i = 1; i < arr.Length(); i++) {
obj = arr.At(i);
if (obj.IsNull()) {
continue;
}
type ^= obj.raw();
bool retain = types_to_retain_.Lookup(&type) != NULL;
if (retain) {
retained_types.Add(type);
} else {
dropped_type_count_++;
}
}
arr = Array::MakeArray(retained_types);
cls.set_canonical_types(arr);
}
}
}
}
void Precompiler::DropTypeArguments() {
const Array& typeargs_table =
Array::Handle(Z, I->object_store()->canonical_type_arguments());
GrowableObjectArray& retained_typeargs =
GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
TypeArguments& typeargs = TypeArguments::Handle(Z);
for (intptr_t i = 0; i < (typeargs_table.Length() - 1); i++) {
typeargs ^= typeargs_table.At(i);
bool retain = typeargs_to_retain_.Lookup(&typeargs) != NULL;
if (retain) {
retained_typeargs.Add(typeargs);
} else {
dropped_typearg_count_++;
}
}
const intptr_t dict_size =
Utils::RoundUpToPowerOfTwo(retained_typeargs.Length() * 4 / 3);
const Array& new_table = Array::Handle(Z, Array::New(dict_size + 1));
Object& element = Object::Handle(Z);
for (intptr_t i = 0; i < retained_typeargs.Length(); i++) {
typeargs ^= retained_typeargs.At(i);
intptr_t hash = typeargs.Hash();
intptr_t index = hash & (dict_size - 1);
element = new_table.At(index);
while (!element.IsNull()) {
index = (index + 1) & (dict_size - 1);
element = new_table.At(index);
}
new_table.SetAt(index, typeargs);
}
const Smi& used = Smi::Handle(Z, Smi::New(retained_typeargs.Length()));
new_table.SetAt(dict_size, used);
I->object_store()->set_canonical_type_arguments(new_table);
}
void Precompiler::TraceTypesFromRetainedClasses() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& members = Array::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
// The subclasses array is only needed for CHA.
cls.ClearDirectSubclasses();
bool retain = false;
members = cls.fields();
if (members.Length() > 0) {
retain = true;
}
members = cls.functions();
if (members.Length() > 0) {
retain = true;
}
if (cls.is_allocated()) {
retain = true;
}
if (cls.is_enum_class()) {
// Enum classes have live instances, so we cannot unregister
// them.
retain = true;
}
members = cls.constants();
if (members.Length() > 0) {
// --compile_all?
retain = true;
}
if (retain) {
AddTypesOf(cls);
}
}
}
}
void Precompiler::DropClasses() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& members = Array::Handle(Z);
String& name = String::Handle(Z);
#if defined(DEBUG)
{
// Force GC for allocation stats.
I->heap()->CollectAllGarbage();
}
#endif
ClassTable* class_table = I->class_table();
intptr_t num_cids = class_table->NumCids();
for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
if (!class_table->IsValidIndex(cid)) continue;
if (!class_table->HasValidClassAt(cid)) continue;
cls = class_table->At(cid);
ASSERT(!cls.IsNull());
if (cls.IsTopLevel()) {
// Top-level classes are referenced directly from their library. They
// will only be removed as a consequence of an entire library being
// removed.
continue;
}
if (cls.is_enum_class()) {
// Enum classes have live instances, so we cannot unregister
// them.
continue;
}
members = cls.constants();
if (members.Length() > 0) {
// --compile_all?
continue;
}
bool retain = classes_to_retain_.Lookup(&cls) != NULL;
if (retain) {
continue;
}
#if defined(DEBUG)
intptr_t instances =
class_table->StatsWithUpdatedSize(cid)->post_gc.new_count +
class_table->StatsWithUpdatedSize(cid)->post_gc.old_count;
if (instances != 0) {
FATAL2("Want to drop class %s, but it has %" Pd " instances\n",
cls.ToCString(),
instances);
}
#endif
dropped_class_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %" Pd " %s\n", cid, cls.ToCString());
}
#if defined(DEBUG)
class_table->Unregister(cid);
#endif
cls.set_id(kIllegalCid); // We check this when serializing.
lib = cls.library();
name = cls.DictionaryName();
lib.RemoveObject(cls, name);
}
}
void Precompiler::DropLibraries() {
const GrowableObjectArray& retained_libraries =
GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
Library& lib = Library::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
lib.DropDependencies();
intptr_t entries = 0;
DictionaryIterator it(lib);
while (it.HasNext()) {
it.GetNext();
entries++;
}
bool retain = (entries > 0) || lib.is_dart_scheme();
if (retain) {
lib.set_index(retained_libraries.Length());
retained_libraries.Add(lib);
} else {
dropped_library_count_++;
lib.set_index(-1);
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n", lib.ToCString());
}
}
}
I->object_store()->set_libraries(retained_libraries);
libraries_ = retained_libraries.raw();
}
void Precompiler::BindStaticCalls() {
class BindStaticCallsVisitor : public FunctionVisitor {
public:
explicit BindStaticCallsVisitor(Zone* zone) :
code_(Code::Handle(zone)),
table_(Array::Handle(zone)),
pc_offset_(Smi::Handle(zone)),
target_(Function::Handle(zone)),
target_code_(Code::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
table_ = code_.static_calls_target_table();
for (intptr_t i = 0;
i < table_.Length();
i += Code::kSCallTableEntryLength) {
pc_offset_ ^= table_.At(i + Code::kSCallTableOffsetEntry);
target_ ^= table_.At(i + Code::kSCallTableFunctionEntry);
if (target_.IsNull()) {
target_code_ ^= table_.At(i + Code::kSCallTableCodeEntry);
ASSERT(!target_code_.IsNull());
ASSERT(!target_code_.IsFunctionCode());
// Allocation stub or AllocateContext or AllocateArray or ...
} else {
// Static calls initially call the CallStaticFunction stub because
// their target might not be compiled yet. After tree shaking, all
// static call targets are compiled.
// Cf. runtime entry PatchStaticCall called from CallStaticFunction
// stub.
ASSERT(target_.HasCode());
target_code_ ^= target_.CurrentCode();
uword pc = pc_offset_.Value() + code_.EntryPoint();
CodePatcher::PatchStaticCallAt(pc, code_, target_code_);
}
}
// We won't patch static calls anymore, so drop the static call table to
// save space.
code_.set_static_calls_target_table(Object::empty_array());
}
private:
Code& code_;
Array& table_;
Smi& pc_offset_;
Function& target_;
Code& target_code_;
};
BindStaticCallsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::DedupStackmaps() {
class DedupStackmapsVisitor : public FunctionVisitor {
public:
explicit DedupStackmapsVisitor(Zone* zone) :
zone_(zone),
canonical_stackmaps_(),
code_(Code::Handle(zone)),
stackmaps_(Array::Handle(zone)),
stackmap_(Stackmap::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
stackmaps_ = code_.stackmaps();
if (stackmaps_.IsNull()) return;
for (intptr_t i = 0; i < stackmaps_.Length(); i++) {
stackmap_ ^= stackmaps_.At(i);
stackmap_ = DedupStackmap(stackmap_);
stackmaps_.SetAt(i, stackmap_);
}
}
RawStackmap* DedupStackmap(const Stackmap& stackmap) {
const Stackmap* canonical_stackmap =
canonical_stackmaps_.Lookup(&stackmap);
if (canonical_stackmap == NULL) {
canonical_stackmaps_.Insert(
&Stackmap::ZoneHandle(zone_, stackmap.raw()));
return stackmap.raw();
} else {
return canonical_stackmap->raw();
}
}
private:
Zone* zone_;
StackmapSet canonical_stackmaps_;
Code& code_;
Array& stackmaps_;
Stackmap& stackmap_;
};
DedupStackmapsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::DedupStackmapLists() {
class DedupStackmapListsVisitor : public FunctionVisitor {
public:
explicit DedupStackmapListsVisitor(Zone* zone) :
zone_(zone),
canonical_stackmap_lists_(),
code_(Code::Handle(zone)),
stackmaps_(Array::Handle(zone)),
stackmap_(Stackmap::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
stackmaps_ = code_.stackmaps();
if (stackmaps_.IsNull()) return;
stackmaps_ = DedupStackmapList(stackmaps_);
code_.set_stackmaps(stackmaps_);
}
RawArray* DedupStackmapList(const Array& stackmaps) {
const Array* canonical_stackmap_list =
canonical_stackmap_lists_.Lookup(&stackmaps);
if (canonical_stackmap_list == NULL) {
canonical_stackmap_lists_.Insert(
&Array::ZoneHandle(zone_, stackmaps.raw()));
return stackmaps.raw();
} else {
return canonical_stackmap_list->raw();
}
}
private:
Zone* zone_;
ArraySet canonical_stackmap_lists_;
Code& code_;
Array& stackmaps_;
Stackmap& stackmap_;
};
DedupStackmapListsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::DedupInstructions() {
class DedupInstructionsVisitor : public FunctionVisitor {
public:
explicit DedupInstructionsVisitor(Zone* zone) :
zone_(zone),
canonical_instructions_set_(),
code_(Code::Handle(zone)),
instructions_(Instructions::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
instructions_ = code_.instructions();
instructions_ = DedupOneInstructions(instructions_);
code_.SetActiveInstructions(instructions_.raw());
code_.set_instructions(instructions_.raw());
function.SetInstructions(code_); // Update cached entry point.
}
RawInstructions* DedupOneInstructions(const Instructions& instructions) {
const Instructions* canonical_instructions =
canonical_instructions_set_.Lookup(&instructions);
if (canonical_instructions == NULL) {
canonical_instructions_set_.Insert(
&Instructions::ZoneHandle(zone_, instructions.raw()));
return instructions.raw();
} else {
return canonical_instructions->raw();
}
}
private:
Zone* zone_;
InstructionsSet canonical_instructions_set_;
Code& code_;
Instructions& instructions_;
};
DedupInstructionsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::VisitFunctions(FunctionVisitor* visitor) {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Object& object = Object::Handle(Z);
Function& function = Function::Handle(Z);
GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
functions = cls.functions();
for (intptr_t j = 0; j < functions.Length(); j++) {
function ^= functions.At(j);
visitor->VisitFunction(function);
if (function.HasImplicitClosureFunction()) {
function = function.ImplicitClosureFunction();
visitor->VisitFunction(function);
}
}
functions = cls.invocation_dispatcher_cache();
for (intptr_t j = 0; j < functions.Length(); j++) {
object = functions.At(j);
if (object.IsFunction()) {
function ^= functions.At(j);
visitor->VisitFunction(function);
}
}
}
}
closures = isolate()->object_store()->closure_functions();
for (intptr_t j = 0; j < closures.Length(); j++) {
function ^= closures.At(j);
visitor->VisitFunction(function);
ASSERT(!function.HasImplicitClosureFunction());
}
}
void Precompiler::FinalizeAllClasses() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
if (!lib.Loaded()) {
String& uri = String::Handle(Z, lib.url());
String& msg = String::Handle(Z, String::NewFormatted(
"Library '%s' is not loaded. "
"Did you forget to call Dart_FinalizeLoading?", uri.ToCString()));
Jump(Error::Handle(Z, ApiError::New(msg)));
}
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
error_ = cls.EnsureIsFinalized(T);
if (!error_.IsNull()) {
Jump(error_);
}
}
}
I->set_all_classes_finalized(true);
}
void Precompiler::ResetPrecompilerState() {
changed_ = false;
function_count_ = 0;
class_count_ = 0;
selector_count_ = 0;
dropped_function_count_ = 0;
dropped_field_count_ = 0;
ASSERT(pending_functions_.Length() == 0);
sent_selectors_.Clear();
enqueued_functions_.Clear();
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
cls.set_is_allocated(false);
}
}
}
void PrecompileParsedFunctionHelper::FinalizeCompilation(
Assembler* assembler,
FlowGraphCompiler* graph_compiler,
FlowGraph* flow_graph) {
const Function& function = parsed_function()->function();
Zone* const zone = thread()->zone();
CSTAT_TIMER_SCOPE(thread(), codefinalizer_timer);
// CreateDeoptInfo uses the object pool and needs to be done before
// FinalizeCode.
const Array& deopt_info_array =
Array::Handle(zone, graph_compiler->CreateDeoptInfo(assembler));
INC_STAT(thread(), total_code_size,
deopt_info_array.Length() * sizeof(uword));
// Allocates instruction object. Since this occurs only at safepoint,
// there can be no concurrent access to the instruction page.
const Code& code = Code::Handle(
Code::FinalizeCode(function, assembler, optimized()));
code.set_is_optimized(optimized());
code.set_owner(function);
if (!function.IsOptimizable()) {
// A function with huge unoptimized code can become non-optimizable
// after generating unoptimized code.
function.set_usage_counter(INT_MIN);
}
const Array& intervals = graph_compiler->inlined_code_intervals();
INC_STAT(thread(), total_code_size,
intervals.Length() * sizeof(uword));
code.SetInlinedIntervals(intervals);
const Array& inlined_id_array =
Array::Handle(zone, graph_compiler->InliningIdToFunction());
INC_STAT(thread(), total_code_size,
inlined_id_array.Length() * sizeof(uword));
code.SetInlinedIdToFunction(inlined_id_array);
const Array& caller_inlining_id_map_array =
Array::Handle(zone, graph_compiler->CallerInliningIdMap());
INC_STAT(thread(), total_code_size,
caller_inlining_id_map_array.Length() * sizeof(uword));
code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
graph_compiler->FinalizePcDescriptors(code);
code.set_deopt_info_array(deopt_info_array);
graph_compiler->FinalizeStackmaps(code);
graph_compiler->FinalizeVarDescriptors(code);
graph_compiler->FinalizeExceptionHandlers(code);
graph_compiler->FinalizeStaticCallTargetsTable(code);
if (optimized()) {
// Installs code while at safepoint.
ASSERT(thread()->IsMutatorThread());
function.InstallOptimizedCode(code, /* is_osr = */ false);
} else { // not optimized.
function.set_unoptimized_code(code);
function.AttachCode(code);
}
ASSERT(!parsed_function()->HasDeferredPrefixes());
ASSERT(FLAG_load_deferred_eagerly);
}
// Return false if bailed out.
// If optimized_result_code is not NULL then it is caller's responsibility
// to install code.
bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
ASSERT(FLAG_precompiled_mode);
const Function& function = parsed_function()->function();
if (optimized() && !function.IsOptimizable()) {
return false;
}
bool is_compiled = false;
Zone* const zone = thread()->zone();
#ifndef PRODUCT
TimelineStream* compiler_timeline = isolate()->GetCompilerStream();
#endif // !PRODUCT
CSTAT_TIMER_SCOPE(thread(), codegen_timer);
HANDLESCOPE(thread());
// We may reattempt compilation if the function needs to be assembled using
// far branches on ARM and MIPS. In the else branch of the setjmp call,
// done is set to false, and use_far_branches is set to true if there is a
// longjmp from the ARM or MIPS assemblers. In all other paths through this
// while loop, done is set to true. use_far_branches is always false on ia32
// and x64.
bool done = false;
// volatile because the variable may be clobbered by a longjmp.
volatile bool use_far_branches = false;
volatile bool use_speculative_inlining =
FLAG_max_speculative_inlining_attempts > 0;
GrowableArray<intptr_t> inlining_black_list;
while (!done) {
const intptr_t prev_deopt_id = thread()->deopt_id();
thread()->set_deopt_id(0);
LongJumpScope jump;
const intptr_t val = setjmp(*jump.Set());
if (val == 0) {
FlowGraph* flow_graph = NULL;
// Class hierarchy analysis is registered with the isolate in the
// constructor and unregisters itself upon destruction.
CHA cha(thread());
// TimerScope needs an isolate to be properly terminated in case of a
// LongJump.
{
CSTAT_TIMER_SCOPE(thread(), graphbuilder_timer);
ZoneGrowableArray<const ICData*>* ic_data_array =
new(zone) ZoneGrowableArray<const ICData*>();
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"BuildFlowGraph");
#endif // !PRODUCT
flow_graph = pipeline->BuildFlowGraph(zone,
parsed_function(),
*ic_data_array,
Compiler::kNoOSRDeoptId);
}
const bool print_flow_graph =
(FLAG_print_flow_graph ||
(optimized() && FLAG_print_flow_graph_optimized)) &&
FlowGraphPrinter::ShouldPrint(function);
if (print_flow_graph) {
FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
}
if (optimized()) {
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"ComputeSSA");
#endif // !PRODUCT
CSTAT_TIMER_SCOPE(thread(), ssa_timer);
// Transform to SSA (virtual register 0 and no inlining arguments).
flow_graph->ComputeSSA(0, NULL);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
if (print_flow_graph) {
FlowGraphPrinter::PrintGraph("After SSA", flow_graph);
}
}
// Maps inline_id_to_function[inline_id] -> function. Top scope
// function has inline_id 0. The map is populated by the inliner.
GrowableArray<const Function*> inline_id_to_function;
// Token position where inlining occured.
GrowableArray<TokenPosition> inline_id_to_token_pos;
// For a given inlining-id(index) specifies the caller's inlining-id.
GrowableArray<intptr_t> caller_inline_id;
// Collect all instance fields that are loaded in the graph and
// have non-generic type feedback attached to them that can
// potentially affect optimizations.
if (optimized()) {
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"OptimizationPasses");
#endif // !PRODUCT
inline_id_to_function.Add(&function);
inline_id_to_token_pos.Add(function.token_pos());
// Top scope function has no caller (-1).
caller_inline_id.Add(-1);
CSTAT_TIMER_SCOPE(thread(), graphoptimizer_timer);
AotOptimizer optimizer(flow_graph,
use_speculative_inlining,
&inlining_black_list);
optimizer.PopulateWithICData();
optimizer.ApplyClassIds();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
optimizer.ApplyICData();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Optimize (a << b) & c patterns, merge operations.
// Run early in order to have more opportunity to optimize left shifts.
optimizer.TryOptimizePatterns();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphInliner::SetInliningId(flow_graph, 0);
// Inlining (mutates the flow graph)
if (FLAG_use_inlining) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"Inlining");
#endif // !PRODUCT
CSTAT_TIMER_SCOPE(thread(), graphinliner_timer);
// Propagate types to create more inlining opportunities.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Use propagated class-ids to create more inlining opportunities.
optimizer.ApplyClassIds();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphInliner inliner(flow_graph,
&inline_id_to_function,
&inline_id_to_token_pos,
&caller_inline_id,
use_speculative_inlining,
&inlining_black_list);
inliner.Inline();
// Use lists are maintained and validated by the inliner.
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Propagate types and eliminate more type tests.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"ApplyClassIds");
#endif // !PRODUCT
// Use propagated class-ids to optimize further.
optimizer.ApplyClassIds();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Propagate types for potentially newly added instructions by
// ApplyClassIds(). Must occur before canonicalization.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Do optimizations that depend on the propagated type information.
if (flow_graph->Canonicalize()) {
// Invoke Canonicalize twice in order to fully canonicalize patterns
// like "if (a & const == 0) { }".
flow_graph->Canonicalize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"BranchSimplifier");
#endif // !PRODUCT
BranchSimplifier::Simplify(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
IfConverter::Simplify(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
if (FLAG_constant_propagation) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"ConstantPropagation");
#endif // !PRODUCT
ConstantPropagator::Optimize(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// A canonicalization pass to remove e.g. smi checks on smi constants.
flow_graph->Canonicalize();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Canonicalization introduced more opportunities for constant
// propagation.
ConstantPropagator::Optimize(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Optimistically convert loop phis that have a single non-smi input
// coming from the loop pre-header into smi-phis.
if (FLAG_loop_invariant_code_motion) {
LICM licm(flow_graph);
licm.OptimisticallySpecializeSmiPhis();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Propagate types and eliminate even more type tests.
// Recompute types after constant propagation to infer more precise
// types for uses that were previously reached by now eliminated phis.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"SelectRepresentations");
#endif // !PRODUCT
// Where beneficial convert Smi operations into Int32 operations.
// Only meanigful for 32bit platforms right now.
flow_graph->WidenSmiToInt32();
// Unbox doubles. Performed after constant propagation to minimize
// interference from phis merging double values and tagged
// values coming from dead paths.
flow_graph->SelectRepresentations();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"CommonSubexpressionElinination");
#endif // !PRODUCT
if (FLAG_common_subexpression_elimination ||
FLAG_loop_invariant_code_motion) {
flow_graph->ComputeBlockEffects();
}
if (FLAG_common_subexpression_elimination) {
if (DominatorBasedCSE::Optimize(flow_graph)) {
DEBUG_ASSERT(flow_graph->VerifyUseLists());
flow_graph->Canonicalize();
// Do another round of CSE to take secondary effects into account:
// e.g. when eliminating dependent loads (a.x[0] + a.x[0])
// TODO(fschneider): Change to a one-pass optimization pass.
if (DominatorBasedCSE::Optimize(flow_graph)) {
flow_graph->Canonicalize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
}
// Run loop-invariant code motion right after load elimination since
// it depends on the numbering of loads from the previous
// load-elimination.
if (FLAG_loop_invariant_code_motion) {
LICM licm(flow_graph);
licm.Optimize();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
flow_graph->RemoveRedefinitions();
}
// Optimize (a << b) & c patterns, merge operations.
// Run after CSE in order to have more opportunity to merge
// instructions that have same inputs.
optimizer.TryOptimizePatterns();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"DeadStoreElimination");
#endif // !PRODUCT
DeadStoreElimination::Optimize(flow_graph);
}
if (FLAG_range_analysis) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"RangeAnalysis");
#endif // !PRODUCT
// Propagate types after store-load-forwarding. Some phis may have
// become smi phis that can be processed by range analysis.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// We have to perform range analysis after LICM because it
// optimistically moves CheckSmi through phis into loop preheaders
// making some phis smi.
RangeAnalysis range_analysis(flow_graph);
range_analysis.Analyze();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
if (FLAG_constant_propagation) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"ConstantPropagator::OptimizeBranches");
#endif // !PRODUCT
// Constant propagation can use information from range analysis to
// find unreachable branch targets and eliminate branches that have
// the same true- and false-target.
ConstantPropagator::OptimizeBranches(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Recompute types after code movement was done to ensure correct
// reaching types for hoisted values.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"TryCatchAnalyzer::Optimize");
#endif // !PRODUCT
// Optimize try-blocks.
TryCatchAnalyzer::Optimize(flow_graph);
}
// Detach environments from the instructions that can't deoptimize.
// Do it before we attempt to perform allocation sinking to minimize
// amount of materializations it has to perform.
flow_graph->EliminateEnvironments();
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"EliminateDeadPhis");
#endif // !PRODUCT
DeadCodeElimination::EliminateDeadPhis(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
if (flow_graph->Canonicalize()) {
flow_graph->Canonicalize();
}
// Attempt to sink allocations of temporary non-escaping objects to
// the deoptimization path.
AllocationSinking* sinking = NULL;
if (FLAG_allocation_sinking &&
(flow_graph->graph_entry()->SuccessorCount() == 1)) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"AllocationSinking::Optimize");
#endif // !PRODUCT
// TODO(fschneider): Support allocation sinking with try-catch.
sinking = new AllocationSinking(flow_graph);
sinking->Optimize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
DeadCodeElimination::EliminateDeadPhis(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"SelectRepresentations");
#endif // !PRODUCT
// Ensure that all phis inserted by optimization passes have
// consistent representations.
flow_graph->SelectRepresentations();
}
if (flow_graph->Canonicalize()) {
// To fully remove redundant boxing (e.g. BoxDouble used only in
// environments and UnboxDouble instructions) instruction we
// first need to replace all their uses and then fold them away.
// For now we just repeat Canonicalize twice to do that.
// TODO(vegorov): implement a separate representation folding pass.
flow_graph->Canonicalize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
if (sinking != NULL) {
#ifndef PRODUCT
TimelineDurationScope tds2(
thread(),
compiler_timeline,
"AllocationSinking::DetachMaterializations");
#endif // !PRODUCT
// Remove all MaterializeObject instructions inserted by allocation
// sinking from the flow graph and let them float on the side
// referenced only from environments. Register allocator will consider
// them as part of a deoptimization environment.
sinking->DetachMaterializations();
}
// Compute and store graph informations (call & instruction counts)
// to be later used by the inliner.
FlowGraphInliner::CollectGraphInfo(flow_graph, true);
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"AllocateRegisters");
#endif // !PRODUCT
// Perform register allocation on the SSA graph.
FlowGraphAllocator allocator(*flow_graph);
allocator.AllocateRegisters();
}
if (print_flow_graph) {
FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
}
}
ASSERT(inline_id_to_function.length() == caller_inline_id.length());
Assembler assembler(use_far_branches);
FlowGraphCompiler graph_compiler(&assembler, flow_graph,
*parsed_function(), optimized(),
inline_id_to_function,
inline_id_to_token_pos,
caller_inline_id);
{
CSTAT_TIMER_SCOPE(thread(), graphcompiler_timer);
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"CompileGraph");
#endif // !PRODUCT
graph_compiler.CompileGraph();
pipeline->FinalizeCompilation();
}
{
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"FinalizeCompilation");
#endif // !PRODUCT
ASSERT(thread()->IsMutatorThread());
FinalizeCompilation(&assembler, &graph_compiler, flow_graph);
}
// Mark that this isolate now has compiled code.
isolate()->set_has_compiled_code(true);
// Exit the loop and the function with the correct result value.
is_compiled = true;
done = true;
} else {
// We bailed out or we encountered an error.
const Error& error = Error::Handle(thread()->sticky_error());
if (error.raw() == Object::branch_offset_error().raw()) {
// Compilation failed due to an out of range branch offset in the
// assembler. We try again (done = false) with far branches enabled.
done = false;
ASSERT(!use_far_branches);
use_far_branches = true;
} else if (error.raw() == Object::speculative_inlining_error().raw()) {
// The return value of setjmp is the deopt id of the check instruction
// that caused the bailout.
done = false;
#if defined(DEBUG)
ASSERT(use_speculative_inlining);
for (intptr_t i = 0; i < inlining_black_list.length(); ++i) {
ASSERT(inlining_black_list[i] != val);
}
#endif
inlining_black_list.Add(val);
const intptr_t max_attempts = FLAG_max_speculative_inlining_attempts;
if (inlining_black_list.length() >= max_attempts) {
use_speculative_inlining = false;
if (FLAG_trace_compiler || FLAG_trace_optimizing_compiler) {
THR_Print("Disabled speculative inlining after %" Pd " attempts.\n",
inlining_black_list.length());
}
}
} else {
// If the error isn't due to an out of range branch offset, we don't
// try again (done = true), and indicate that we did not finish
// compiling (is_compiled = false).
if (FLAG_trace_bailout) {
THR_Print("%s\n", error.ToErrorCString());
}
done = true;
}
// Clear the error if it was not a real error, but just a bailout.
if (error.IsLanguageError() &&
(LanguageError::Cast(error).kind() == Report::kBailout)) {
thread()->clear_sticky_error();
}
is_compiled = false;
}
// Reset global isolate state.
thread()->set_deopt_id(prev_deopt_id);
}
return is_compiled;
}
static RawError* PrecompileFunctionHelper(CompilationPipeline* pipeline,
const Function& function,
bool optimized) {
// Check that we optimize, except if the function is not optimizable.
ASSERT(FLAG_precompiled_mode);
ASSERT(!function.IsOptimizable() || optimized);
ASSERT(!function.HasCode());
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
Thread* const thread = Thread::Current();
StackZone stack_zone(thread);
Zone* const zone = stack_zone.GetZone();
const bool trace_compiler =
FLAG_trace_compiler ||
(FLAG_trace_optimizing_compiler && optimized);
Timer per_compile_timer(trace_compiler, "Compilation time");
per_compile_timer.Start();
ParsedFunction* parsed_function = new(zone) ParsedFunction(
thread, Function::ZoneHandle(zone, function.raw()));
if (trace_compiler) {
THR_Print(
"Precompiling %sfunction: '%s' @ token %" Pd ", size %" Pd "\n",
(optimized ? "optimized " : ""),
function.ToFullyQualifiedCString(),
function.token_pos().Pos(),
(function.end_token_pos().Pos() - function.token_pos().Pos()));
}
INC_STAT(thread, num_functions_compiled, 1);
if (optimized) {
INC_STAT(thread, num_functions_optimized, 1);
}
{
HANDLESCOPE(thread);
const int64_t num_tokens_before = STAT_VALUE(thread, num_tokens_consumed);
pipeline->ParseFunction(parsed_function);
const int64_t num_tokens_after = STAT_VALUE(thread, num_tokens_consumed);
INC_STAT(thread,
num_func_tokens_compiled,
num_tokens_after - num_tokens_before);
}
PrecompileParsedFunctionHelper helper(parsed_function, optimized);
const bool success = helper.Compile(pipeline);
if (!success) {
// Encountered error.
Error& error = Error::Handle();
// We got an error during compilation.
error = thread->sticky_error();
thread->clear_sticky_error();
ASSERT(error.IsLanguageError() &&
LanguageError::Cast(error).kind() != Report::kBailout);
return error.raw();
}
per_compile_timer.Stop();
if (trace_compiler && success) {
THR_Print("--> '%s' entry: %#" Px " size: %" Pd " time: %" Pd64 " us\n",
function.ToFullyQualifiedCString(),
Code::Handle(function.CurrentCode()).EntryPoint(),
Code::Handle(function.CurrentCode()).Size(),
per_compile_timer.TotalElapsedTime());
}
if (FLAG_disassemble && FlowGraphPrinter::ShouldPrint(function)) {
Disassembler::DisassembleCode(function, optimized);
} else if (FLAG_disassemble_optimized &&
optimized &&
FlowGraphPrinter::ShouldPrint(function)) {
// TODO(fschneider): Print unoptimized code along with the optimized code.
THR_Print("*** BEGIN CODE\n");
Disassembler::DisassembleCode(function, true);
THR_Print("*** END CODE\n");
}
return Error::null();
} else {
Thread* const thread = Thread::Current();
StackZone stack_zone(thread);
Error& error = Error::Handle();
// We got an error during compilation.
error = thread->sticky_error();
thread->clear_sticky_error();
// Precompilation may encounter compile-time errors.
// Do not attempt to optimize functions that can cause errors.
function.set_is_optimizable(false);
return error.raw();
}
UNREACHABLE();
return Error::null();
}
RawError* Precompiler::CompileFunction(Thread* thread,
const Function& function) {
VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "Function", function);
CompilationPipeline* pipeline =
CompilationPipeline::New(thread->zone(), function);
ASSERT(FLAG_precompiled_mode);
const bool optimized = function.IsOptimizable(); // False for natives.
return PrecompileFunctionHelper(pipeline, function, optimized);
}
#endif // DART_PRECOMPILER
} // namespace dart
Precompilation: also trace types of exception handlers.
Cf. 4b112c6d25fa714ad1fa4060a3d4bc4cc40c54eb
R=regis@google.com
Review URL: https://codereview.chromium.org/1746313002 .
// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "vm/precompiler.h"
#include "vm/aot_optimizer.h"
#include "vm/assembler.h"
#include "vm/ast_printer.h"
#include "vm/branch_optimizer.h"
#include "vm/cha.h"
#include "vm/code_generator.h"
#include "vm/code_patcher.h"
#include "vm/compiler.h"
#include "vm/constant_propagator.h"
#include "vm/dart_entry.h"
#include "vm/disassembler.h"
#include "vm/exceptions.h"
#include "vm/flags.h"
#include "vm/flow_graph.h"
#include "vm/flow_graph_allocator.h"
#include "vm/flow_graph_builder.h"
#include "vm/flow_graph_compiler.h"
#include "vm/flow_graph_inliner.h"
#include "vm/flow_graph_range_analysis.h"
#include "vm/flow_graph_type_propagator.h"
#include "vm/hash_table.h"
#include "vm/il_printer.h"
#include "vm/isolate.h"
#include "vm/log.h"
#include "vm/longjump.h"
#include "vm/object.h"
#include "vm/object_store.h"
#include "vm/os.h"
#include "vm/parser.h"
#include "vm/redundancy_elimination.h"
#include "vm/regexp_assembler.h"
#include "vm/regexp_parser.h"
#include "vm/resolver.h"
#include "vm/symbols.h"
#include "vm/tags.h"
#include "vm/timer.h"
namespace dart {
#define T (thread())
#define I (isolate())
#define Z (zone())
DEFINE_FLAG(bool, print_unique_targets, false, "Print unique dynaic targets");
DEFINE_FLAG(bool, trace_precompiler, false, "Trace precompiler.");
DEFINE_FLAG(int, max_speculative_inlining_attempts, 1,
"Max number of attempts with speculative inlining (precompilation only)");
DECLARE_FLAG(bool, allocation_sinking);
DECLARE_FLAG(bool, common_subexpression_elimination);
DECLARE_FLAG(bool, constant_propagation);
DECLARE_FLAG(bool, loop_invariant_code_motion);
DECLARE_FLAG(bool, print_flow_graph);
DECLARE_FLAG(bool, print_flow_graph_optimized);
DECLARE_FLAG(bool, range_analysis);
DECLARE_FLAG(bool, trace_compiler);
DECLARE_FLAG(bool, trace_optimizing_compiler);
DECLARE_FLAG(bool, trace_bailout);
DECLARE_FLAG(bool, use_inlining);
DECLARE_FLAG(bool, verify_compiler);
DECLARE_FLAG(bool, huge_method_cutoff_in_code_size);
DECLARE_FLAG(bool, trace_failed_optimization_attempts);
DECLARE_FLAG(bool, trace_inlining_intervals);
DECLARE_FLAG(bool, trace_irregexp);
#ifdef DART_PRECOMPILER
class PrecompileParsedFunctionHelper : public ValueObject {
public:
PrecompileParsedFunctionHelper(ParsedFunction* parsed_function,
bool optimized)
: parsed_function_(parsed_function),
optimized_(optimized),
thread_(Thread::Current()) {
}
bool Compile(CompilationPipeline* pipeline);
private:
ParsedFunction* parsed_function() const { return parsed_function_; }
bool optimized() const { return optimized_; }
Thread* thread() const { return thread_; }
Isolate* isolate() const { return thread_->isolate(); }
void FinalizeCompilation(Assembler* assembler,
FlowGraphCompiler* graph_compiler,
FlowGraph* flow_graph);
ParsedFunction* parsed_function_;
const bool optimized_;
Thread* const thread_;
DISALLOW_COPY_AND_ASSIGN(PrecompileParsedFunctionHelper);
};
static void Jump(const Error& error) {
Thread::Current()->long_jump_base()->Jump(1, error);
}
RawError* Precompiler::CompileAll(
Dart_QualifiedFunctionName embedder_entry_points[],
bool reset_fields) {
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
Precompiler precompiler(Thread::Current(), reset_fields);
precompiler.DoCompileAll(embedder_entry_points);
return Error::null();
} else {
Thread* thread = Thread::Current();
const Error& error = Error::Handle(thread->sticky_error());
thread->clear_sticky_error();
return error.raw();
}
}
Precompiler::Precompiler(Thread* thread, bool reset_fields) :
thread_(thread),
zone_(NULL),
isolate_(thread->isolate()),
reset_fields_(reset_fields),
changed_(false),
function_count_(0),
class_count_(0),
selector_count_(0),
dropped_function_count_(0),
dropped_field_count_(0),
dropped_class_count_(0),
dropped_typearg_count_(0),
dropped_type_count_(0),
dropped_library_count_(0),
libraries_(GrowableObjectArray::Handle(I->object_store()->libraries())),
pending_functions_(
GrowableObjectArray::Handle(GrowableObjectArray::New())),
sent_selectors_(),
enqueued_functions_(),
fields_to_retain_(),
classes_to_retain_(),
typeargs_to_retain_(),
types_to_retain_(),
error_(Error::Handle()) {
}
void Precompiler::DoCompileAll(
Dart_QualifiedFunctionName embedder_entry_points[]) {
ASSERT(I->compilation_allowed());
{
StackZone stack_zone(T);
zone_ = stack_zone.GetZone();
// Make sure class hierarchy is stable before compilation so that CHA
// can be used. Also ensures lookup of entry points won't miss functions
// because their class hasn't been finalized yet.
FinalizeAllClasses();
const intptr_t kPrecompilerRounds = 1;
for (intptr_t round = 0; round < kPrecompilerRounds; round++) {
if (FLAG_trace_precompiler) {
THR_Print("Precompiler round %" Pd "\n", round);
}
if (round > 0) {
ResetPrecompilerState();
}
// TODO(rmacnak): We should be able to do a more thorough job and drop
// some
// - implicit static closures
// - field initializers
// - invoke-field-dispatchers
// - method-extractors
// that are needed in early iterations but optimized away in later
// iterations.
ClearAllCode();
CollectDynamicFunctionNames();
// Start with the allocations and invocations that happen from C++.
AddRoots(embedder_entry_points);
// Compile newly found targets and add their callees until we reach a
// fixed point.
Iterate();
}
I->set_compilation_allowed(false);
DropFunctions();
DropFields();
TraceTypesFromRetainedClasses();
DropTypes();
DropTypeArguments();
DropClasses();
DropLibraries();
BindStaticCalls();
DedupStackmaps();
DedupStackmapLists();
if (FLAG_dedup_instructions) {
// Reduces binary size but obfuscates profiler results.
DedupInstructions();
}
I->object_store()->set_compile_time_constants(Array::null_array());
I->object_store()->set_unique_dynamic_targets(Array::null_array());
zone_ = NULL;
}
intptr_t dropped_symbols_count = Symbols::Compact(I);
if (FLAG_trace_precompiler) {
THR_Print("Precompiled %" Pd " functions,", function_count_);
THR_Print(" %" Pd " dynamic types,", class_count_);
THR_Print(" %" Pd " dynamic selectors.\n", selector_count_);
THR_Print("Dropped %" Pd " functions,", dropped_function_count_);
THR_Print(" %" Pd " fields,", dropped_field_count_);
THR_Print(" %" Pd " symbols,", dropped_symbols_count);
THR_Print(" %" Pd " types,", dropped_type_count_);
THR_Print(" %" Pd " type arguments,", dropped_typearg_count_);
THR_Print(" %" Pd " classes,", dropped_class_count_);
THR_Print(" %" Pd " libraries.\n", dropped_library_count_);
}
}
void Precompiler::ClearAllCode() {
class ClearCodeFunctionVisitor : public FunctionVisitor {
void VisitFunction(const Function& function) {
function.ClearCode();
function.ClearICDataArray();
}
};
ClearCodeFunctionVisitor visitor;
VisitFunctions(&visitor);
}
void Precompiler::AddRoots(Dart_QualifiedFunctionName embedder_entry_points[]) {
// Note that <rootlibrary>.main is not a root. The appropriate main will be
// discovered through _getMainClosure.
AddSelector(Symbols::NoSuchMethod());
AddSelector(Symbols::Call()); // For speed, not correctness.
// Allocated from C++.
Class& cls = Class::Handle(Z);
for (intptr_t cid = kInstanceCid; cid < kNumPredefinedCids; cid++) {
ASSERT(isolate()->class_table()->IsValidIndex(cid));
if (!isolate()->class_table()->HasValidClassAt(cid)) {
continue;
}
if ((cid == kDynamicCid) ||
(cid == kVoidCid) ||
(cid == kFreeListElement)) {
continue;
}
cls = isolate()->class_table()->At(cid);
AddInstantiatedClass(cls);
}
Dart_QualifiedFunctionName vm_entry_points[] = {
// Functions
{ "dart:async", "::", "_setScheduleImmediateClosure" },
{ "dart:core", "::", "_completeDeferredLoads" },
{ "dart:core", "AbstractClassInstantiationError",
"AbstractClassInstantiationError._create" },
{ "dart:core", "ArgumentError", "ArgumentError." },
{ "dart:core", "CyclicInitializationError",
"CyclicInitializationError." },
{ "dart:core", "FallThroughError", "FallThroughError._create" },
{ "dart:core", "FormatException", "FormatException." },
{ "dart:core", "NoSuchMethodError", "NoSuchMethodError._withType" },
{ "dart:core", "NullThrownError", "NullThrownError." },
{ "dart:core", "OutOfMemoryError", "OutOfMemoryError." },
{ "dart:core", "RangeError", "RangeError." },
{ "dart:core", "RangeError", "RangeError.range" },
{ "dart:core", "StackOverflowError", "StackOverflowError." },
{ "dart:core", "UnsupportedError", "UnsupportedError." },
{ "dart:core", "_AssertionError", "_AssertionError._create" },
{ "dart:core", "_CastError", "_CastError._create" },
{ "dart:core", "_InternalError", "_InternalError." },
{ "dart:core", "_InvocationMirror", "_allocateInvocationMirror" },
{ "dart:core", "_TypeError", "_TypeError._create" },
{ "dart:isolate", "IsolateSpawnException", "IsolateSpawnException." },
{ "dart:isolate", "::", "_getIsolateScheduleImmediateClosure" },
{ "dart:isolate", "::", "_setupHooks" },
{ "dart:isolate", "::", "_startMainIsolate" },
{ "dart:isolate", "_RawReceivePortImpl", "_handleMessage" },
{ "dart:isolate", "_RawReceivePortImpl", "_lookupHandler" },
{ "dart:isolate", "_SendPortImpl", "send" },
{ "dart:typed_data", "ByteData", "ByteData." },
{ "dart:typed_data", "ByteData", "ByteData._view" },
{ "dart:typed_data", "_ByteBuffer", "_ByteBuffer._New" },
{ "dart:_vmservice", "::", "_registerIsolate" },
{ "dart:_vmservice", "::", "boot" },
{ "dart:developer", "Metrics", "_printMetrics" },
// Fields
{ "dart:core", "Error", "_stackTrace" },
{ "dart:math", "_Random", "_state" },
{ NULL, NULL, NULL } // Must be terminated with NULL entries.
};
AddEntryPoints(vm_entry_points);
AddEntryPoints(embedder_entry_points);
}
void Precompiler::AddEntryPoints(Dart_QualifiedFunctionName entry_points[]) {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Function& func = Function::Handle(Z);
Field& field = Field::Handle(Z);
String& library_uri = String::Handle(Z);
String& class_name = String::Handle(Z);
String& function_name = String::Handle(Z);
for (intptr_t i = 0; entry_points[i].library_uri != NULL; i++) {
library_uri = Symbols::New(entry_points[i].library_uri);
class_name = Symbols::New(entry_points[i].class_name);
function_name = Symbols::New(entry_points[i].function_name);
lib = Library::LookupLibrary(library_uri);
if (lib.IsNull()) {
String& msg = String::Handle(Z, String::NewFormatted(
"Cannot find entry point %s\n", entry_points[i].library_uri));
Jump(Error::Handle(Z, ApiError::New(msg)));
UNREACHABLE();
}
if (class_name.raw() == Symbols::TopLevel().raw()) {
if (Library::IsPrivate(function_name)) {
function_name = lib.PrivateName(function_name);
}
func = lib.LookupLocalFunction(function_name);
field = lib.LookupLocalField(function_name);
} else {
if (Library::IsPrivate(class_name)) {
class_name = lib.PrivateName(class_name);
}
cls = lib.LookupLocalClass(class_name);
if (cls.IsNull()) {
String& msg = String::Handle(Z, String::NewFormatted(
"Cannot find entry point %s %s\n",
entry_points[i].library_uri,
entry_points[i].class_name));
Jump(Error::Handle(Z, ApiError::New(msg)));
UNREACHABLE();
}
ASSERT(!cls.IsNull());
func = cls.LookupFunctionAllowPrivate(function_name);
field = cls.LookupField(function_name);
}
if (func.IsNull() && field.IsNull()) {
String& msg = String::Handle(Z, String::NewFormatted(
"Cannot find entry point %s %s %s\n",
entry_points[i].library_uri,
entry_points[i].class_name,
entry_points[i].function_name));
Jump(Error::Handle(Z, ApiError::New(msg)));
UNREACHABLE();
}
if (!func.IsNull()) {
AddFunction(func);
if (func.IsGenerativeConstructor()) {
// Allocation stubs are referenced from the call site of the
// constructor, not in the constructor itself. So compiling the
// constructor isn't enough for us to discover the class is
// instantiated if the class isn't otherwise instantiated from Dart
// code and only instantiated from C++.
AddInstantiatedClass(cls);
}
}
if (!field.IsNull()) {
AddField(field);
}
}
}
void Precompiler::Iterate() {
Function& function = Function::Handle(Z);
while (changed_) {
changed_ = false;
while (pending_functions_.Length() > 0) {
function ^= pending_functions_.RemoveLast();
ProcessFunction(function);
}
CheckForNewDynamicFunctions();
}
}
void Precompiler::ProcessFunction(const Function& function) {
if (!function.HasCode()) {
function_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompiling %" Pd " %s (%s, %s)\n",
function_count_,
function.ToLibNamePrefixedQualifiedCString(),
function.token_pos().ToCString(),
Function::KindToCString(function.kind()));
}
ASSERT(!function.is_abstract());
ASSERT(!function.IsRedirectingFactory());
error_ = CompileFunction(thread_, function);
if (!error_.IsNull()) {
Jump(error_);
}
// Used in the JIT to save type-feedback across compilations.
function.ClearICDataArray();
} else {
if (FLAG_trace_precompiler) {
// This function was compiled from somewhere other than Precompiler,
// such as const constructors compiled by the parser.
THR_Print("Already has code: %s (%s, %s)\n",
function.ToLibNamePrefixedQualifiedCString(),
function.token_pos().ToCString(),
Function::KindToCString(function.kind()));
}
}
ASSERT(function.HasCode());
AddCalleesOf(function);
}
void Precompiler::AddCalleesOf(const Function& function) {
ASSERT(function.HasCode());
const Code& code = Code::Handle(Z, function.CurrentCode());
const Array& table = Array::Handle(Z, code.static_calls_target_table());
Object& entry = Object::Handle(Z);
Function& target = Function::Handle(Z);
for (intptr_t i = 0; i < table.Length(); i++) {
entry = table.At(i);
if (entry.IsFunction()) {
target ^= entry.raw();
AddFunction(target);
}
}
#if defined(TARGET_ARCH_IA32)
FATAL("Callee scanning unimplemented for IA32");
#endif
const ObjectPool& pool = ObjectPool::Handle(Z, code.GetObjectPool());
ICData& call_site = ICData::Handle(Z);
MegamorphicCache& cache = MegamorphicCache::Handle(Z);
String& selector = String::Handle(Z);
Field& field = Field::Handle(Z);
Class& cls = Class::Handle(Z);
Instance& instance = Instance::Handle(Z);
Code& target_code = Code::Handle(Z);
for (intptr_t i = 0; i < pool.Length(); i++) {
if (pool.InfoAt(i) == ObjectPool::kTaggedObject) {
entry = pool.ObjectAt(i);
if (entry.IsICData()) {
call_site ^= entry.raw();
for (intptr_t j = 0; j < call_site.NumberOfChecks(); j++) {
target = call_site.GetTargetAt(j);
AddFunction(target);
if (!target.is_static()) {
// Super call (should not enqueue selector) or dynamic call with a
// CHA prediction (should enqueue selector).
selector = call_site.target_name();
AddSelector(selector);
}
}
if (call_site.NumberOfChecks() == 0) {
// A dynamic call.
selector = call_site.target_name();
AddSelector(selector);
if (selector.raw() == Symbols::Call().raw()) {
// Potential closure call.
AddClosureCall(call_site);
}
}
} else if (entry.IsMegamorphicCache()) {
// A dynamic call.
cache ^= entry.raw();
selector = cache.target_name();
AddSelector(selector);
} else if (entry.IsField()) {
// Potential need for field initializer.
field ^= entry.raw();
AddField(field);
} else if (entry.IsInstance()) {
// Const object, literal or args descriptor.
instance ^= entry.raw();
if (entry.IsAbstractType()) {
AddType(AbstractType::Cast(entry));
} else {
AddConstObject(instance);
}
} else if (entry.IsFunction()) {
// Local closure function.
target ^= entry.raw();
AddFunction(target);
} else if (entry.IsCode()) {
target_code ^= entry.raw();
if (target_code.IsAllocationStubCode()) {
cls ^= target_code.owner();
AddInstantiatedClass(cls);
}
} else if (entry.IsTypeArguments()) {
AddTypeArguments(TypeArguments::Cast(entry));
}
}
}
}
void Precompiler::AddTypesOf(const Class& cls) {
if (cls.IsNull()) return;
if (classes_to_retain_.Lookup(&cls) != NULL) return;
classes_to_retain_.Insert(&Class::ZoneHandle(Z, cls.raw()));
Array& interfaces = Array::Handle(Z, cls.interfaces());
AbstractType& type = AbstractType::Handle(Z);
for (intptr_t i = 0; i < interfaces.Length(); i++) {
type ^= interfaces.At(i);
AddType(type);
}
AddTypeArguments(TypeArguments::Handle(Z, cls.type_parameters()));
type = cls.super_type();
AddType(type);
type = cls.mixin();
AddType(type);
if (cls.IsTypedefClass()) {
AddTypesOf(Function::Handle(Z, cls.signature_function()));
}
}
void Precompiler::AddTypesOf(const Function& function) {
AbstractType& type = AbstractType::Handle(Z);
type = function.result_type();
AddType(type);
for (intptr_t i = 0; i < function.NumParameters(); i++) {
type = function.ParameterTypeAt(i);
AddType(type);
}
Code& code = Code::Handle(Z, function.CurrentCode());
if (code.IsNull()) {
ASSERT(function.kind() == RawFunction::kSignatureFunction);
} else {
const ExceptionHandlers& handlers =
ExceptionHandlers::Handle(Z, code.exception_handlers());
if (!handlers.IsNull()) {
Array& types = Array::Handle(Z);
for (intptr_t i = 0; i < handlers.num_entries(); i++) {
types = handlers.GetHandledTypes(i);
for (intptr_t j = 0; j < types.Length(); j++) {
type ^= types.At(j);
AddType(type);
}
}
}
}
}
void Precompiler::AddType(const AbstractType& abstype) {
if (abstype.IsNull()) return;
if (types_to_retain_.Lookup(&abstype) != NULL) return;
types_to_retain_.Insert(&AbstractType::ZoneHandle(Z, abstype.raw()));
if (abstype.IsType()) {
const Type& type = Type::Cast(abstype);
const Class& cls = Class::Handle(Z, type.type_class());
AddTypesOf(cls);
const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
AddTypeArguments(vector);
} else if (abstype.IsFunctionType()) {
const FunctionType& func_type = FunctionType::Cast(abstype);
const Class& cls = Class::Handle(Z, func_type.scope_class());
AddTypesOf(cls);
const Function& func = Function::Handle(Z, func_type.signature());
AddTypesOf(func);
const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
AddTypeArguments(vector);
} else if (abstype.IsBoundedType()) {
AbstractType& type = AbstractType::Handle(Z);
type = BoundedType::Cast(abstype).type();
AddType(type);
type = BoundedType::Cast(abstype).bound();
AddType(type);
} else if (abstype.IsTypeRef()) {
AbstractType& type = AbstractType::Handle(Z);
type = TypeRef::Cast(abstype).type();
AddType(type);
}
}
void Precompiler::AddTypeArguments(const TypeArguments& args) {
if (args.IsNull()) return;
if (typeargs_to_retain_.Lookup(&args) != NULL) return;
typeargs_to_retain_.Insert(&TypeArguments::ZoneHandle(Z, args.raw()));
AbstractType& arg = AbstractType::Handle(Z);
for (intptr_t i = 0; i < args.Length(); i++) {
arg = args.TypeAt(i);
AddType(arg);
}
}
void Precompiler::AddConstObject(const Instance& instance) {
const Class& cls = Class::Handle(Z, instance.clazz());
AddInstantiatedClass(cls);
if (instance.IsClosure()) {
// An implicit static closure.
const Function& func =
Function::Handle(Z, Closure::Cast(instance).function());
ASSERT(func.is_static());
AddFunction(func);
AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
return;
}
// Can't ask immediate objects if they're canoncial.
if (instance.IsSmi()) return;
// Some Instances in the ObjectPool aren't const objects, such as
// argument descriptors.
if (!instance.IsCanonical()) return;
if (cls.NumTypeArguments() > 0) {
AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
}
class ConstObjectVisitor : public ObjectPointerVisitor {
public:
ConstObjectVisitor(Precompiler* precompiler, Isolate* isolate) :
ObjectPointerVisitor(isolate),
precompiler_(precompiler),
subinstance_(Object::Handle()) {}
virtual void VisitPointers(RawObject** first, RawObject** last) {
for (RawObject** current = first; current <= last; current++) {
subinstance_ = *current;
if (subinstance_.IsInstance()) {
precompiler_->AddConstObject(Instance::Cast(subinstance_));
}
}
subinstance_ = Object::null();
}
private:
Precompiler* precompiler_;
Object& subinstance_;
};
ConstObjectVisitor visitor(this, I);
instance.raw()->VisitPointers(&visitor);
}
void Precompiler::AddClosureCall(const ICData& call_site) {
const Array& arguments_descriptor =
Array::Handle(Z, call_site.arguments_descriptor());
const Class& cache_class =
Class::Handle(Z, I->object_store()->closure_class());
const Function& dispatcher = Function::Handle(Z,
cache_class.GetInvocationDispatcher(Symbols::Call(),
arguments_descriptor,
RawFunction::kInvokeFieldDispatcher,
true /* create_if_absent */));
AddFunction(dispatcher);
}
void Precompiler::AddField(const Field& field) {
fields_to_retain_.Insert(&Field::ZoneHandle(Z, field.raw()));
if (field.is_static()) {
const Object& value = Object::Handle(Z, field.StaticValue());
if (value.IsInstance()) {
AddConstObject(Instance::Cast(value));
}
if (field.has_initializer()) {
// Should not be in the middle of initialization while precompiling.
ASSERT(value.raw() != Object::transition_sentinel().raw());
const bool is_initialized = value.raw() != Object::sentinel().raw();
if (is_initialized && !reset_fields_) return;
if (!field.HasPrecompiledInitializer()) {
if (FLAG_trace_precompiler) {
THR_Print("Precompiling initializer for %s\n", field.ToCString());
}
ASSERT(!Dart::IsRunningPrecompiledCode());
field.SetStaticValue(Instance::Handle(field.SavedInitialStaticValue()));
const Function& initializer =
Function::Handle(CompileStaticInitializer(field));
if (!initializer.IsNull()) {
field.SetPrecompiledInitializer(initializer);
}
}
const Function& function =
Function::Handle(Z, field.PrecompiledInitializer());
AddCalleesOf(function);
}
}
}
RawFunction* Precompiler::CompileStaticInitializer(const Field& field) {
ASSERT(field.is_static());
if (field.HasPrecompiledInitializer()) {
// TODO(rmacnak): Investigate why this happens for _enum_names.
THR_Print("Warning: Ignoring repeated request for initializer for %s\n",
field.ToCString());
return Function::null();
}
Thread* thread = Thread::Current();
StackZone zone(thread);
ParsedFunction* parsed_function = Parser::ParseStaticFieldInitializer(field);
parsed_function->AllocateVariables();
// Non-optimized code generator.
DartCompilationPipeline pipeline;
PrecompileParsedFunctionHelper helper(parsed_function,
/* optimized = */ false);
helper.Compile(&pipeline);
return parsed_function->function().raw();
}
RawObject* Precompiler::EvaluateStaticInitializer(const Field& field) {
ASSERT(field.is_static());
// The VM sets the field's value to transiton_sentinel prior to
// evaluating the initializer value.
ASSERT(field.StaticValue() == Object::transition_sentinel().raw());
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
// Under precompilation, the initializer may have already been compiled, in
// which case use it. Under lazy compilation or early in precompilation, the
// initializer has not yet been created, so create it now, but don't bother
// remembering it because it won't be used again.
Function& initializer = Function::Handle();
if (!field.HasPrecompiledInitializer()) {
initializer = CompileStaticInitializer(field);
Code::Handle(initializer.unoptimized_code()).set_var_descriptors(
Object::empty_var_descriptors());
} else {
initializer ^= field.PrecompiledInitializer();
}
// Invoke the function to evaluate the expression.
return DartEntry::InvokeFunction(initializer, Object::empty_array());
} else {
Thread* const thread = Thread::Current();
StackZone zone(thread);
const Error& error =
Error::Handle(thread->zone(), thread->sticky_error());
thread->clear_sticky_error();
return error.raw();
}
UNREACHABLE();
return Object::null();
}
RawObject* Precompiler::ExecuteOnce(SequenceNode* fragment) {
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
Thread* const thread = Thread::Current();
if (FLAG_support_ast_printer && FLAG_trace_compiler) {
THR_Print("compiling expression: ");
AstPrinter::PrintNode(fragment);
}
// Create a dummy function object for the code generator.
// The function needs to be associated with a named Class: the interface
// Function fits the bill.
const char* kEvalConst = "eval_const";
const Function& func = Function::ZoneHandle(Function::New(
String::Handle(Symbols::New(kEvalConst)),
RawFunction::kRegularFunction,
true, // static function
false, // not const function
false, // not abstract
false, // not external
false, // not native
Class::Handle(Type::Handle(Type::Function()).type_class()),
fragment->token_pos()));
func.set_result_type(Object::dynamic_type());
func.set_num_fixed_parameters(0);
func.SetNumOptionalParameters(0, true);
// Manually generated AST, do not recompile.
func.SetIsOptimizable(false);
func.set_is_debuggable(false);
// We compile the function here, even though InvokeFunction() below
// would compile func automatically. We are checking fewer invariants
// here.
ParsedFunction* parsed_function = new ParsedFunction(thread, func);
parsed_function->SetNodeSequence(fragment);
fragment->scope()->AddVariable(parsed_function->EnsureExpressionTemp());
fragment->scope()->AddVariable(
parsed_function->current_context_var());
parsed_function->AllocateVariables();
// Non-optimized code generator.
DartCompilationPipeline pipeline;
PrecompileParsedFunctionHelper helper(parsed_function,
/* optimized = */ false);
helper.Compile(&pipeline);
Code::Handle(func.unoptimized_code()).set_var_descriptors(
Object::empty_var_descriptors());
const Object& result = PassiveObject::Handle(
DartEntry::InvokeFunction(func, Object::empty_array()));
return result.raw();
} else {
Thread* const thread = Thread::Current();
const Object& result =
PassiveObject::Handle(thread->sticky_error());
thread->clear_sticky_error();
return result.raw();
}
UNREACHABLE();
return Object::null();
}
void Precompiler::AddFunction(const Function& function) {
if (enqueued_functions_.Lookup(&function) != NULL) return;
enqueued_functions_.Insert(&Function::ZoneHandle(Z, function.raw()));
pending_functions_.Add(function);
changed_ = true;
}
bool Precompiler::IsSent(const String& selector) {
if (selector.IsNull()) {
return false;
}
return sent_selectors_.Lookup(&selector) != NULL;
}
void Precompiler::AddSelector(const String& selector) {
ASSERT(!selector.IsNull());
if (!IsSent(selector)) {
sent_selectors_.Insert(&String::ZoneHandle(Z, selector.raw()));
selector_count_++;
changed_ = true;
if (FLAG_trace_precompiler) {
THR_Print("Enqueueing selector %" Pd " %s\n",
selector_count_,
selector.ToCString());
}
}
}
void Precompiler::AddInstantiatedClass(const Class& cls) {
if (cls.is_allocated()) return;
class_count_++;
cls.set_is_allocated(true);
error_ = cls.EnsureIsFinalized(T);
if (!error_.IsNull()) {
Jump(error_);
}
changed_ = true;
if (FLAG_trace_precompiler) {
THR_Print("Allocation %" Pd " %s\n", class_count_, cls.ToCString());
}
const Class& superclass = Class::Handle(cls.SuperClass());
if (!superclass.IsNull()) {
AddInstantiatedClass(superclass);
}
}
void Precompiler::CheckForNewDynamicFunctions() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Function& function = Function::Handle(Z);
Function& function2 = Function::Handle(Z);
String& selector = String::Handle(Z);
String& selector2 = String::Handle(Z);
String& selector3 = String::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (!cls.is_allocated()) continue;
functions = cls.functions();
for (intptr_t k = 0; k < functions.Length(); k++) {
function ^= functions.At(k);
if (function.is_static() || function.is_abstract()) continue;
// Don't bail out early if there is already code because we may discover
// the corresponding getter selector is sent in some later iteration.
// if (function.HasCode()) continue;
selector = function.name();
if (IsSent(selector)) {
AddFunction(function);
}
// Handle the implicit call type conversions.
if (Field::IsGetterName(selector)) {
selector2 = Field::NameFromGetter(selector);
selector3 = Symbols::Lookup(selector2);
if (IsSent(selector2)) {
// Call-through-getter.
// Function is get:foo and somewhere foo is called.
AddFunction(function);
}
selector3 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
selector2);
if (IsSent(selector3)) {
// Hash-closurization.
// Function is get:foo and somewhere get:#foo is called.
AddFunction(function);
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor get:#foo.
function2 = function.GetMethodExtractor(selector3);
AddFunction(function2);
}
} else if (Field::IsSetterName(selector)) {
selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
selector);
if (IsSent(selector2)) {
// Hash-closurization.
// Function is set:foo and somewhere get:#set:foo is called.
AddFunction(function);
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor get:#set:foo.
function2 = function.GetMethodExtractor(selector2);
AddFunction(function2);
}
} else if (function.kind() == RawFunction::kRegularFunction) {
selector2 = Field::LookupGetterSymbol(selector);
if (IsSent(selector2)) {
// Closurization.
// Function is foo and somewhere get:foo is called.
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor.
function2 = function.GetMethodExtractor(selector2);
AddFunction(function2);
}
selector2 = Symbols::LookupFromConcat(Symbols::ClosurizePrefix(),
selector);
if (IsSent(selector2)) {
// Hash-closurization.
// Function is foo and somewhere get:#foo is called.
function2 = function.ImplicitClosureFunction();
AddFunction(function2);
// Add corresponding method extractor get:#foo
function2 = function.GetMethodExtractor(selector2);
AddFunction(function2);
}
}
}
}
}
}
class NameFunctionsTraits {
public:
static bool IsMatch(const Object& a, const Object& b) {
return a.IsString() && b.IsString() &&
String::Cast(a).Equals(String::Cast(b));
}
static uword Hash(const Object& obj) {
return String::Cast(obj).Hash();
}
static RawObject* NewKey(const String& str) {
return str.raw();
}
};
typedef UnorderedHashMap<NameFunctionsTraits> Table;
static void AddNameToFunctionsTable(Zone* zone,
Table* table,
const String& fname,
const Function& function) {
Array& farray = Array::Handle(zone);
farray ^= table->InsertNewOrGetValue(fname, Array::empty_array());
farray = Array::Grow(farray, farray.Length() + 1);
farray.SetAt(farray.Length() - 1, function);
table->UpdateValue(fname, farray);
}
void Precompiler::CollectDynamicFunctionNames() {
if (!FLAG_collect_dynamic_function_names) {
return;
}
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Function& function = Function::Handle(Z);
String& fname = String::Handle(Z);
Array& farray = Array::Handle(Z);
Table table(HashTables::New<Table>(100));
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
functions = cls.functions();
for (intptr_t j = 0; j < functions.Length(); j++) {
function ^= functions.At(j);
if (function.IsDynamicFunction()) {
fname = function.name();
if (function.IsSetterFunction() ||
function.IsImplicitSetterFunction()) {
AddNameToFunctionsTable(zone(), &table, fname, function);
} else if (function.IsGetterFunction() ||
function.IsImplicitGetterFunction()) {
// Enter both getter and non getter name.
AddNameToFunctionsTable(zone(), &table, fname, function);
fname = Field::NameFromGetter(fname);
AddNameToFunctionsTable(zone(), &table, fname, function);
} else {
// Regular function. Enter both getter and non getter name.
AddNameToFunctionsTable(zone(), &table, fname, function);
fname = Field::GetterName(fname);
AddNameToFunctionsTable(zone(), &table, fname, function);
}
}
}
}
}
// Locate all entries with one function only, and whose owner is neither
// subclassed nor implemented.
Table::Iterator iter(&table);
String& key = String::Handle(Z);
UniqueFunctionsSet functions_set(HashTables::New<UniqueFunctionsSet>(20));
while (iter.MoveNext()) {
intptr_t curr_key = iter.Current();
key ^= table.GetKey(curr_key);
farray ^= table.GetOrNull(key);
ASSERT(!farray.IsNull());
if (farray.Length() == 1) {
function ^= farray.At(0);
cls = function.Owner();
if (!CHA::IsImplemented(cls) && !CHA::HasSubclasses(cls)) {
functions_set.Insert(function);
}
}
}
if (FLAG_print_unique_targets) {
UniqueFunctionsSet::Iterator unique_iter(&functions_set);
while (unique_iter.MoveNext()) {
intptr_t curr_key = unique_iter.Current();
function ^= functions_set.GetKey(curr_key);
THR_Print("* %s\n", function.ToQualifiedCString());
}
THR_Print("%" Pd " of %" Pd " dynamic selectors are unique\n",
functions_set.NumOccupied(), table.NumOccupied());
}
isolate()->object_store()->set_unique_dynamic_targets(
functions_set.Release());
table.Release();
}
void Precompiler::GetUniqueDynamicTarget(Isolate* isolate,
const String& fname,
Object* function) {
UniqueFunctionsSet functions_set(
isolate->object_store()->unique_dynamic_targets());
ASSERT(fname.IsSymbol());
*function = functions_set.GetOrNull(fname);
ASSERT(functions_set.Release().raw() ==
isolate->object_store()->unique_dynamic_targets());
}
void Precompiler::DropFunctions() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Function& function = Function::Handle(Z);
Function& function2 = Function::Handle(Z);
GrowableObjectArray& retained_functions = GrowableObjectArray::Handle(Z);
GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
String& name = String::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
functions = cls.functions();
retained_functions = GrowableObjectArray::New();
for (intptr_t j = 0; j < functions.Length(); j++) {
function ^= functions.At(j);
bool retain = function.HasCode();
if (!retain && function.HasImplicitClosureFunction()) {
// It can happen that all uses of an implicit closure inline their
// target function, leaving the target function uncompiled. Keep
// the target function anyway so we can enumerate it to bind its
// static calls, etc.
function2 = function.ImplicitClosureFunction();
retain = function2.HasCode();
}
if (retain) {
retained_functions.Add(function);
function.DropUncompiledImplicitClosureFunction();
AddTypesOf(function);
} else {
bool top_level = cls.IsTopLevel();
if (top_level &&
(function.kind() != RawFunction::kImplicitStaticFinalGetter)) {
// Implicit static final getters are not added to the library
// dictionary in the first place.
name = function.DictionaryName();
bool removed = lib.RemoveObject(function, name);
ASSERT(removed);
}
dropped_function_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n",
function.ToLibNamePrefixedQualifiedCString());
}
}
}
if (retained_functions.Length() > 0) {
functions = Array::MakeArray(retained_functions);
cls.SetFunctions(functions);
} else {
cls.SetFunctions(Object::empty_array());
}
}
}
closures = isolate()->object_store()->closure_functions();
retained_functions = GrowableObjectArray::New();
for (intptr_t j = 0; j < closures.Length(); j++) {
function ^= closures.At(j);
bool retain = function.HasCode();
if (retain) {
retained_functions.Add(function);
AddTypesOf(function);
} else {
dropped_function_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n",
function.ToLibNamePrefixedQualifiedCString());
}
}
}
isolate()->object_store()->set_closure_functions(retained_functions);
}
void Precompiler::DropFields() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& fields = Array::Handle(Z);
Field& field = Field::Handle(Z);
GrowableObjectArray& retained_fields = GrowableObjectArray::Handle(Z);
String& name = String::Handle(Z);
AbstractType& type = AbstractType::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
fields = cls.fields();
retained_fields = GrowableObjectArray::New();
for (intptr_t j = 0; j < fields.Length(); j++) {
field ^= fields.At(j);
bool retain = fields_to_retain_.Lookup(&field) != NULL;
if (retain) {
retained_fields.Add(field);
type = field.type();
AddType(type);
} else {
bool top_level = cls.IsTopLevel();
if (top_level) {
name = field.DictionaryName();
bool removed = lib.RemoveObject(field, name);
ASSERT(removed);
}
dropped_field_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n",
field.ToCString());
}
}
}
if (retained_fields.Length() > 0) {
fields = Array::MakeArray(retained_fields);
cls.SetFields(fields);
} else {
cls.SetFields(Object::empty_array());
}
}
}
}
void Precompiler::DropTypes() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Object& obj = Object::Handle(Z);
Array& arr = Array::Handle(Z);
GrowableObjectArray& retained_types = GrowableObjectArray::Handle(Z);
AbstractType& type = AbstractType::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
obj = cls.canonical_types();
if (!obj.IsArray()) {
// Class only has one type, keep it.
} else {
// Class has many types.
arr ^= obj.raw();
retained_types = GrowableObjectArray::New();
// Always keep the first one.
ASSERT(arr.Length() >= 1);
obj = arr.At(0);
retained_types.Add(obj);
for (intptr_t i = 1; i < arr.Length(); i++) {
obj = arr.At(i);
if (obj.IsNull()) {
continue;
}
type ^= obj.raw();
bool retain = types_to_retain_.Lookup(&type) != NULL;
if (retain) {
retained_types.Add(type);
} else {
dropped_type_count_++;
}
}
arr = Array::MakeArray(retained_types);
cls.set_canonical_types(arr);
}
}
}
}
void Precompiler::DropTypeArguments() {
const Array& typeargs_table =
Array::Handle(Z, I->object_store()->canonical_type_arguments());
GrowableObjectArray& retained_typeargs =
GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
TypeArguments& typeargs = TypeArguments::Handle(Z);
for (intptr_t i = 0; i < (typeargs_table.Length() - 1); i++) {
typeargs ^= typeargs_table.At(i);
bool retain = typeargs_to_retain_.Lookup(&typeargs) != NULL;
if (retain) {
retained_typeargs.Add(typeargs);
} else {
dropped_typearg_count_++;
}
}
const intptr_t dict_size =
Utils::RoundUpToPowerOfTwo(retained_typeargs.Length() * 4 / 3);
const Array& new_table = Array::Handle(Z, Array::New(dict_size + 1));
Object& element = Object::Handle(Z);
for (intptr_t i = 0; i < retained_typeargs.Length(); i++) {
typeargs ^= retained_typeargs.At(i);
intptr_t hash = typeargs.Hash();
intptr_t index = hash & (dict_size - 1);
element = new_table.At(index);
while (!element.IsNull()) {
index = (index + 1) & (dict_size - 1);
element = new_table.At(index);
}
new_table.SetAt(index, typeargs);
}
const Smi& used = Smi::Handle(Z, Smi::New(retained_typeargs.Length()));
new_table.SetAt(dict_size, used);
I->object_store()->set_canonical_type_arguments(new_table);
}
void Precompiler::TraceTypesFromRetainedClasses() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& members = Array::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
// The subclasses array is only needed for CHA.
cls.ClearDirectSubclasses();
bool retain = false;
members = cls.fields();
if (members.Length() > 0) {
retain = true;
}
members = cls.functions();
if (members.Length() > 0) {
retain = true;
}
if (cls.is_allocated()) {
retain = true;
}
if (cls.is_enum_class()) {
// Enum classes have live instances, so we cannot unregister
// them.
retain = true;
}
members = cls.constants();
if (members.Length() > 0) {
// --compile_all?
retain = true;
}
if (retain) {
AddTypesOf(cls);
}
}
}
}
void Precompiler::DropClasses() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& members = Array::Handle(Z);
String& name = String::Handle(Z);
#if defined(DEBUG)
{
// Force GC for allocation stats.
I->heap()->CollectAllGarbage();
}
#endif
ClassTable* class_table = I->class_table();
intptr_t num_cids = class_table->NumCids();
for (intptr_t cid = kNumPredefinedCids; cid < num_cids; cid++) {
if (!class_table->IsValidIndex(cid)) continue;
if (!class_table->HasValidClassAt(cid)) continue;
cls = class_table->At(cid);
ASSERT(!cls.IsNull());
if (cls.IsTopLevel()) {
// Top-level classes are referenced directly from their library. They
// will only be removed as a consequence of an entire library being
// removed.
continue;
}
if (cls.is_enum_class()) {
// Enum classes have live instances, so we cannot unregister
// them.
continue;
}
members = cls.constants();
if (members.Length() > 0) {
// --compile_all?
continue;
}
bool retain = classes_to_retain_.Lookup(&cls) != NULL;
if (retain) {
continue;
}
#if defined(DEBUG)
intptr_t instances =
class_table->StatsWithUpdatedSize(cid)->post_gc.new_count +
class_table->StatsWithUpdatedSize(cid)->post_gc.old_count;
if (instances != 0) {
FATAL2("Want to drop class %s, but it has %" Pd " instances\n",
cls.ToCString(),
instances);
}
#endif
dropped_class_count_++;
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %" Pd " %s\n", cid, cls.ToCString());
}
#if defined(DEBUG)
class_table->Unregister(cid);
#endif
cls.set_id(kIllegalCid); // We check this when serializing.
lib = cls.library();
name = cls.DictionaryName();
lib.RemoveObject(cls, name);
}
}
void Precompiler::DropLibraries() {
const GrowableObjectArray& retained_libraries =
GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
Library& lib = Library::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
lib.DropDependencies();
intptr_t entries = 0;
DictionaryIterator it(lib);
while (it.HasNext()) {
it.GetNext();
entries++;
}
bool retain = (entries > 0) || lib.is_dart_scheme();
if (retain) {
lib.set_index(retained_libraries.Length());
retained_libraries.Add(lib);
} else {
dropped_library_count_++;
lib.set_index(-1);
if (FLAG_trace_precompiler) {
THR_Print("Precompilation dropping %s\n", lib.ToCString());
}
}
}
I->object_store()->set_libraries(retained_libraries);
libraries_ = retained_libraries.raw();
}
void Precompiler::BindStaticCalls() {
class BindStaticCallsVisitor : public FunctionVisitor {
public:
explicit BindStaticCallsVisitor(Zone* zone) :
code_(Code::Handle(zone)),
table_(Array::Handle(zone)),
pc_offset_(Smi::Handle(zone)),
target_(Function::Handle(zone)),
target_code_(Code::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
table_ = code_.static_calls_target_table();
for (intptr_t i = 0;
i < table_.Length();
i += Code::kSCallTableEntryLength) {
pc_offset_ ^= table_.At(i + Code::kSCallTableOffsetEntry);
target_ ^= table_.At(i + Code::kSCallTableFunctionEntry);
if (target_.IsNull()) {
target_code_ ^= table_.At(i + Code::kSCallTableCodeEntry);
ASSERT(!target_code_.IsNull());
ASSERT(!target_code_.IsFunctionCode());
// Allocation stub or AllocateContext or AllocateArray or ...
} else {
// Static calls initially call the CallStaticFunction stub because
// their target might not be compiled yet. After tree shaking, all
// static call targets are compiled.
// Cf. runtime entry PatchStaticCall called from CallStaticFunction
// stub.
ASSERT(target_.HasCode());
target_code_ ^= target_.CurrentCode();
uword pc = pc_offset_.Value() + code_.EntryPoint();
CodePatcher::PatchStaticCallAt(pc, code_, target_code_);
}
}
// We won't patch static calls anymore, so drop the static call table to
// save space.
code_.set_static_calls_target_table(Object::empty_array());
}
private:
Code& code_;
Array& table_;
Smi& pc_offset_;
Function& target_;
Code& target_code_;
};
BindStaticCallsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::DedupStackmaps() {
class DedupStackmapsVisitor : public FunctionVisitor {
public:
explicit DedupStackmapsVisitor(Zone* zone) :
zone_(zone),
canonical_stackmaps_(),
code_(Code::Handle(zone)),
stackmaps_(Array::Handle(zone)),
stackmap_(Stackmap::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
stackmaps_ = code_.stackmaps();
if (stackmaps_.IsNull()) return;
for (intptr_t i = 0; i < stackmaps_.Length(); i++) {
stackmap_ ^= stackmaps_.At(i);
stackmap_ = DedupStackmap(stackmap_);
stackmaps_.SetAt(i, stackmap_);
}
}
RawStackmap* DedupStackmap(const Stackmap& stackmap) {
const Stackmap* canonical_stackmap =
canonical_stackmaps_.Lookup(&stackmap);
if (canonical_stackmap == NULL) {
canonical_stackmaps_.Insert(
&Stackmap::ZoneHandle(zone_, stackmap.raw()));
return stackmap.raw();
} else {
return canonical_stackmap->raw();
}
}
private:
Zone* zone_;
StackmapSet canonical_stackmaps_;
Code& code_;
Array& stackmaps_;
Stackmap& stackmap_;
};
DedupStackmapsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::DedupStackmapLists() {
class DedupStackmapListsVisitor : public FunctionVisitor {
public:
explicit DedupStackmapListsVisitor(Zone* zone) :
zone_(zone),
canonical_stackmap_lists_(),
code_(Code::Handle(zone)),
stackmaps_(Array::Handle(zone)),
stackmap_(Stackmap::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
stackmaps_ = code_.stackmaps();
if (stackmaps_.IsNull()) return;
stackmaps_ = DedupStackmapList(stackmaps_);
code_.set_stackmaps(stackmaps_);
}
RawArray* DedupStackmapList(const Array& stackmaps) {
const Array* canonical_stackmap_list =
canonical_stackmap_lists_.Lookup(&stackmaps);
if (canonical_stackmap_list == NULL) {
canonical_stackmap_lists_.Insert(
&Array::ZoneHandle(zone_, stackmaps.raw()));
return stackmaps.raw();
} else {
return canonical_stackmap_list->raw();
}
}
private:
Zone* zone_;
ArraySet canonical_stackmap_lists_;
Code& code_;
Array& stackmaps_;
Stackmap& stackmap_;
};
DedupStackmapListsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::DedupInstructions() {
class DedupInstructionsVisitor : public FunctionVisitor {
public:
explicit DedupInstructionsVisitor(Zone* zone) :
zone_(zone),
canonical_instructions_set_(),
code_(Code::Handle(zone)),
instructions_(Instructions::Handle(zone)) {
}
void VisitFunction(const Function& function) {
if (!function.HasCode()) {
ASSERT(function.HasImplicitClosureFunction());
return;
}
code_ = function.CurrentCode();
instructions_ = code_.instructions();
instructions_ = DedupOneInstructions(instructions_);
code_.SetActiveInstructions(instructions_.raw());
code_.set_instructions(instructions_.raw());
function.SetInstructions(code_); // Update cached entry point.
}
RawInstructions* DedupOneInstructions(const Instructions& instructions) {
const Instructions* canonical_instructions =
canonical_instructions_set_.Lookup(&instructions);
if (canonical_instructions == NULL) {
canonical_instructions_set_.Insert(
&Instructions::ZoneHandle(zone_, instructions.raw()));
return instructions.raw();
} else {
return canonical_instructions->raw();
}
}
private:
Zone* zone_;
InstructionsSet canonical_instructions_set_;
Code& code_;
Instructions& instructions_;
};
DedupInstructionsVisitor visitor(Z);
VisitFunctions(&visitor);
}
void Precompiler::VisitFunctions(FunctionVisitor* visitor) {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
Array& functions = Array::Handle(Z);
Object& object = Object::Handle(Z);
Function& function = Function::Handle(Z);
GrowableObjectArray& closures = GrowableObjectArray::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
functions = cls.functions();
for (intptr_t j = 0; j < functions.Length(); j++) {
function ^= functions.At(j);
visitor->VisitFunction(function);
if (function.HasImplicitClosureFunction()) {
function = function.ImplicitClosureFunction();
visitor->VisitFunction(function);
}
}
functions = cls.invocation_dispatcher_cache();
for (intptr_t j = 0; j < functions.Length(); j++) {
object = functions.At(j);
if (object.IsFunction()) {
function ^= functions.At(j);
visitor->VisitFunction(function);
}
}
}
}
closures = isolate()->object_store()->closure_functions();
for (intptr_t j = 0; j < closures.Length(); j++) {
function ^= closures.At(j);
visitor->VisitFunction(function);
ASSERT(!function.HasImplicitClosureFunction());
}
}
void Precompiler::FinalizeAllClasses() {
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
if (!lib.Loaded()) {
String& uri = String::Handle(Z, lib.url());
String& msg = String::Handle(Z, String::NewFormatted(
"Library '%s' is not loaded. "
"Did you forget to call Dart_FinalizeLoading?", uri.ToCString()));
Jump(Error::Handle(Z, ApiError::New(msg)));
}
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
error_ = cls.EnsureIsFinalized(T);
if (!error_.IsNull()) {
Jump(error_);
}
}
}
I->set_all_classes_finalized(true);
}
void Precompiler::ResetPrecompilerState() {
changed_ = false;
function_count_ = 0;
class_count_ = 0;
selector_count_ = 0;
dropped_function_count_ = 0;
dropped_field_count_ = 0;
ASSERT(pending_functions_.Length() == 0);
sent_selectors_.Clear();
enqueued_functions_.Clear();
Library& lib = Library::Handle(Z);
Class& cls = Class::Handle(Z);
for (intptr_t i = 0; i < libraries_.Length(); i++) {
lib ^= libraries_.At(i);
ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
while (it.HasNext()) {
cls = it.GetNextClass();
if (cls.IsDynamicClass()) {
continue; // class 'dynamic' is in the read-only VM isolate.
}
cls.set_is_allocated(false);
}
}
}
void PrecompileParsedFunctionHelper::FinalizeCompilation(
Assembler* assembler,
FlowGraphCompiler* graph_compiler,
FlowGraph* flow_graph) {
const Function& function = parsed_function()->function();
Zone* const zone = thread()->zone();
CSTAT_TIMER_SCOPE(thread(), codefinalizer_timer);
// CreateDeoptInfo uses the object pool and needs to be done before
// FinalizeCode.
const Array& deopt_info_array =
Array::Handle(zone, graph_compiler->CreateDeoptInfo(assembler));
INC_STAT(thread(), total_code_size,
deopt_info_array.Length() * sizeof(uword));
// Allocates instruction object. Since this occurs only at safepoint,
// there can be no concurrent access to the instruction page.
const Code& code = Code::Handle(
Code::FinalizeCode(function, assembler, optimized()));
code.set_is_optimized(optimized());
code.set_owner(function);
if (!function.IsOptimizable()) {
// A function with huge unoptimized code can become non-optimizable
// after generating unoptimized code.
function.set_usage_counter(INT_MIN);
}
const Array& intervals = graph_compiler->inlined_code_intervals();
INC_STAT(thread(), total_code_size,
intervals.Length() * sizeof(uword));
code.SetInlinedIntervals(intervals);
const Array& inlined_id_array =
Array::Handle(zone, graph_compiler->InliningIdToFunction());
INC_STAT(thread(), total_code_size,
inlined_id_array.Length() * sizeof(uword));
code.SetInlinedIdToFunction(inlined_id_array);
const Array& caller_inlining_id_map_array =
Array::Handle(zone, graph_compiler->CallerInliningIdMap());
INC_STAT(thread(), total_code_size,
caller_inlining_id_map_array.Length() * sizeof(uword));
code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
graph_compiler->FinalizePcDescriptors(code);
code.set_deopt_info_array(deopt_info_array);
graph_compiler->FinalizeStackmaps(code);
graph_compiler->FinalizeVarDescriptors(code);
graph_compiler->FinalizeExceptionHandlers(code);
graph_compiler->FinalizeStaticCallTargetsTable(code);
if (optimized()) {
// Installs code while at safepoint.
ASSERT(thread()->IsMutatorThread());
function.InstallOptimizedCode(code, /* is_osr = */ false);
} else { // not optimized.
function.set_unoptimized_code(code);
function.AttachCode(code);
}
ASSERT(!parsed_function()->HasDeferredPrefixes());
ASSERT(FLAG_load_deferred_eagerly);
}
// Return false if bailed out.
// If optimized_result_code is not NULL then it is caller's responsibility
// to install code.
bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
ASSERT(FLAG_precompiled_mode);
const Function& function = parsed_function()->function();
if (optimized() && !function.IsOptimizable()) {
return false;
}
bool is_compiled = false;
Zone* const zone = thread()->zone();
#ifndef PRODUCT
TimelineStream* compiler_timeline = isolate()->GetCompilerStream();
#endif // !PRODUCT
CSTAT_TIMER_SCOPE(thread(), codegen_timer);
HANDLESCOPE(thread());
// We may reattempt compilation if the function needs to be assembled using
// far branches on ARM and MIPS. In the else branch of the setjmp call,
// done is set to false, and use_far_branches is set to true if there is a
// longjmp from the ARM or MIPS assemblers. In all other paths through this
// while loop, done is set to true. use_far_branches is always false on ia32
// and x64.
bool done = false;
// volatile because the variable may be clobbered by a longjmp.
volatile bool use_far_branches = false;
volatile bool use_speculative_inlining =
FLAG_max_speculative_inlining_attempts > 0;
GrowableArray<intptr_t> inlining_black_list;
while (!done) {
const intptr_t prev_deopt_id = thread()->deopt_id();
thread()->set_deopt_id(0);
LongJumpScope jump;
const intptr_t val = setjmp(*jump.Set());
if (val == 0) {
FlowGraph* flow_graph = NULL;
// Class hierarchy analysis is registered with the isolate in the
// constructor and unregisters itself upon destruction.
CHA cha(thread());
// TimerScope needs an isolate to be properly terminated in case of a
// LongJump.
{
CSTAT_TIMER_SCOPE(thread(), graphbuilder_timer);
ZoneGrowableArray<const ICData*>* ic_data_array =
new(zone) ZoneGrowableArray<const ICData*>();
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"BuildFlowGraph");
#endif // !PRODUCT
flow_graph = pipeline->BuildFlowGraph(zone,
parsed_function(),
*ic_data_array,
Compiler::kNoOSRDeoptId);
}
const bool print_flow_graph =
(FLAG_print_flow_graph ||
(optimized() && FLAG_print_flow_graph_optimized)) &&
FlowGraphPrinter::ShouldPrint(function);
if (print_flow_graph) {
FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
}
if (optimized()) {
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"ComputeSSA");
#endif // !PRODUCT
CSTAT_TIMER_SCOPE(thread(), ssa_timer);
// Transform to SSA (virtual register 0 and no inlining arguments).
flow_graph->ComputeSSA(0, NULL);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
if (print_flow_graph) {
FlowGraphPrinter::PrintGraph("After SSA", flow_graph);
}
}
// Maps inline_id_to_function[inline_id] -> function. Top scope
// function has inline_id 0. The map is populated by the inliner.
GrowableArray<const Function*> inline_id_to_function;
// Token position where inlining occured.
GrowableArray<TokenPosition> inline_id_to_token_pos;
// For a given inlining-id(index) specifies the caller's inlining-id.
GrowableArray<intptr_t> caller_inline_id;
// Collect all instance fields that are loaded in the graph and
// have non-generic type feedback attached to them that can
// potentially affect optimizations.
if (optimized()) {
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"OptimizationPasses");
#endif // !PRODUCT
inline_id_to_function.Add(&function);
inline_id_to_token_pos.Add(function.token_pos());
// Top scope function has no caller (-1).
caller_inline_id.Add(-1);
CSTAT_TIMER_SCOPE(thread(), graphoptimizer_timer);
AotOptimizer optimizer(flow_graph,
use_speculative_inlining,
&inlining_black_list);
optimizer.PopulateWithICData();
optimizer.ApplyClassIds();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
optimizer.ApplyICData();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Optimize (a << b) & c patterns, merge operations.
// Run early in order to have more opportunity to optimize left shifts.
optimizer.TryOptimizePatterns();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphInliner::SetInliningId(flow_graph, 0);
// Inlining (mutates the flow graph)
if (FLAG_use_inlining) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"Inlining");
#endif // !PRODUCT
CSTAT_TIMER_SCOPE(thread(), graphinliner_timer);
// Propagate types to create more inlining opportunities.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Use propagated class-ids to create more inlining opportunities.
optimizer.ApplyClassIds();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphInliner inliner(flow_graph,
&inline_id_to_function,
&inline_id_to_token_pos,
&caller_inline_id,
use_speculative_inlining,
&inlining_black_list);
inliner.Inline();
// Use lists are maintained and validated by the inliner.
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Propagate types and eliminate more type tests.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"ApplyClassIds");
#endif // !PRODUCT
// Use propagated class-ids to optimize further.
optimizer.ApplyClassIds();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Propagate types for potentially newly added instructions by
// ApplyClassIds(). Must occur before canonicalization.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Do optimizations that depend on the propagated type information.
if (flow_graph->Canonicalize()) {
// Invoke Canonicalize twice in order to fully canonicalize patterns
// like "if (a & const == 0) { }".
flow_graph->Canonicalize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"BranchSimplifier");
#endif // !PRODUCT
BranchSimplifier::Simplify(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
IfConverter::Simplify(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
if (FLAG_constant_propagation) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"ConstantPropagation");
#endif // !PRODUCT
ConstantPropagator::Optimize(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// A canonicalization pass to remove e.g. smi checks on smi constants.
flow_graph->Canonicalize();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// Canonicalization introduced more opportunities for constant
// propagation.
ConstantPropagator::Optimize(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Optimistically convert loop phis that have a single non-smi input
// coming from the loop pre-header into smi-phis.
if (FLAG_loop_invariant_code_motion) {
LICM licm(flow_graph);
licm.OptimisticallySpecializeSmiPhis();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Propagate types and eliminate even more type tests.
// Recompute types after constant propagation to infer more precise
// types for uses that were previously reached by now eliminated phis.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"SelectRepresentations");
#endif // !PRODUCT
// Where beneficial convert Smi operations into Int32 operations.
// Only meanigful for 32bit platforms right now.
flow_graph->WidenSmiToInt32();
// Unbox doubles. Performed after constant propagation to minimize
// interference from phis merging double values and tagged
// values coming from dead paths.
flow_graph->SelectRepresentations();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"CommonSubexpressionElinination");
#endif // !PRODUCT
if (FLAG_common_subexpression_elimination ||
FLAG_loop_invariant_code_motion) {
flow_graph->ComputeBlockEffects();
}
if (FLAG_common_subexpression_elimination) {
if (DominatorBasedCSE::Optimize(flow_graph)) {
DEBUG_ASSERT(flow_graph->VerifyUseLists());
flow_graph->Canonicalize();
// Do another round of CSE to take secondary effects into account:
// e.g. when eliminating dependent loads (a.x[0] + a.x[0])
// TODO(fschneider): Change to a one-pass optimization pass.
if (DominatorBasedCSE::Optimize(flow_graph)) {
flow_graph->Canonicalize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
}
// Run loop-invariant code motion right after load elimination since
// it depends on the numbering of loads from the previous
// load-elimination.
if (FLAG_loop_invariant_code_motion) {
LICM licm(flow_graph);
licm.Optimize();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
flow_graph->RemoveRedefinitions();
}
// Optimize (a << b) & c patterns, merge operations.
// Run after CSE in order to have more opportunity to merge
// instructions that have same inputs.
optimizer.TryOptimizePatterns();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"DeadStoreElimination");
#endif // !PRODUCT
DeadStoreElimination::Optimize(flow_graph);
}
if (FLAG_range_analysis) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"RangeAnalysis");
#endif // !PRODUCT
// Propagate types after store-load-forwarding. Some phis may have
// become smi phis that can be processed by range analysis.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
// We have to perform range analysis after LICM because it
// optimistically moves CheckSmi through phis into loop preheaders
// making some phis smi.
RangeAnalysis range_analysis(flow_graph);
range_analysis.Analyze();
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
if (FLAG_constant_propagation) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"ConstantPropagator::OptimizeBranches");
#endif // !PRODUCT
// Constant propagation can use information from range analysis to
// find unreachable branch targets and eliminate branches that have
// the same true- and false-target.
ConstantPropagator::OptimizeBranches(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
// Recompute types after code movement was done to ensure correct
// reaching types for hoisted values.
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"TryCatchAnalyzer::Optimize");
#endif // !PRODUCT
// Optimize try-blocks.
TryCatchAnalyzer::Optimize(flow_graph);
}
// Detach environments from the instructions that can't deoptimize.
// Do it before we attempt to perform allocation sinking to minimize
// amount of materializations it has to perform.
flow_graph->EliminateEnvironments();
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"EliminateDeadPhis");
#endif // !PRODUCT
DeadCodeElimination::EliminateDeadPhis(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
}
if (flow_graph->Canonicalize()) {
flow_graph->Canonicalize();
}
// Attempt to sink allocations of temporary non-escaping objects to
// the deoptimization path.
AllocationSinking* sinking = NULL;
if (FLAG_allocation_sinking &&
(flow_graph->graph_entry()->SuccessorCount() == 1)) {
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"AllocationSinking::Optimize");
#endif // !PRODUCT
// TODO(fschneider): Support allocation sinking with try-catch.
sinking = new AllocationSinking(flow_graph);
sinking->Optimize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
DeadCodeElimination::EliminateDeadPhis(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
FlowGraphTypePropagator::Propagate(flow_graph);
DEBUG_ASSERT(flow_graph->VerifyUseLists());
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"SelectRepresentations");
#endif // !PRODUCT
// Ensure that all phis inserted by optimization passes have
// consistent representations.
flow_graph->SelectRepresentations();
}
if (flow_graph->Canonicalize()) {
// To fully remove redundant boxing (e.g. BoxDouble used only in
// environments and UnboxDouble instructions) instruction we
// first need to replace all their uses and then fold them away.
// For now we just repeat Canonicalize twice to do that.
// TODO(vegorov): implement a separate representation folding pass.
flow_graph->Canonicalize();
}
DEBUG_ASSERT(flow_graph->VerifyUseLists());
if (sinking != NULL) {
#ifndef PRODUCT
TimelineDurationScope tds2(
thread(),
compiler_timeline,
"AllocationSinking::DetachMaterializations");
#endif // !PRODUCT
// Remove all MaterializeObject instructions inserted by allocation
// sinking from the flow graph and let them float on the side
// referenced only from environments. Register allocator will consider
// them as part of a deoptimization environment.
sinking->DetachMaterializations();
}
// Compute and store graph informations (call & instruction counts)
// to be later used by the inliner.
FlowGraphInliner::CollectGraphInfo(flow_graph, true);
{
#ifndef PRODUCT
TimelineDurationScope tds2(thread(),
compiler_timeline,
"AllocateRegisters");
#endif // !PRODUCT
// Perform register allocation on the SSA graph.
FlowGraphAllocator allocator(*flow_graph);
allocator.AllocateRegisters();
}
if (print_flow_graph) {
FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
}
}
ASSERT(inline_id_to_function.length() == caller_inline_id.length());
Assembler assembler(use_far_branches);
FlowGraphCompiler graph_compiler(&assembler, flow_graph,
*parsed_function(), optimized(),
inline_id_to_function,
inline_id_to_token_pos,
caller_inline_id);
{
CSTAT_TIMER_SCOPE(thread(), graphcompiler_timer);
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"CompileGraph");
#endif // !PRODUCT
graph_compiler.CompileGraph();
pipeline->FinalizeCompilation();
}
{
#ifndef PRODUCT
TimelineDurationScope tds(thread(),
compiler_timeline,
"FinalizeCompilation");
#endif // !PRODUCT
ASSERT(thread()->IsMutatorThread());
FinalizeCompilation(&assembler, &graph_compiler, flow_graph);
}
// Mark that this isolate now has compiled code.
isolate()->set_has_compiled_code(true);
// Exit the loop and the function with the correct result value.
is_compiled = true;
done = true;
} else {
// We bailed out or we encountered an error.
const Error& error = Error::Handle(thread()->sticky_error());
if (error.raw() == Object::branch_offset_error().raw()) {
// Compilation failed due to an out of range branch offset in the
// assembler. We try again (done = false) with far branches enabled.
done = false;
ASSERT(!use_far_branches);
use_far_branches = true;
} else if (error.raw() == Object::speculative_inlining_error().raw()) {
// The return value of setjmp is the deopt id of the check instruction
// that caused the bailout.
done = false;
#if defined(DEBUG)
ASSERT(use_speculative_inlining);
for (intptr_t i = 0; i < inlining_black_list.length(); ++i) {
ASSERT(inlining_black_list[i] != val);
}
#endif
inlining_black_list.Add(val);
const intptr_t max_attempts = FLAG_max_speculative_inlining_attempts;
if (inlining_black_list.length() >= max_attempts) {
use_speculative_inlining = false;
if (FLAG_trace_compiler || FLAG_trace_optimizing_compiler) {
THR_Print("Disabled speculative inlining after %" Pd " attempts.\n",
inlining_black_list.length());
}
}
} else {
// If the error isn't due to an out of range branch offset, we don't
// try again (done = true), and indicate that we did not finish
// compiling (is_compiled = false).
if (FLAG_trace_bailout) {
THR_Print("%s\n", error.ToErrorCString());
}
done = true;
}
// Clear the error if it was not a real error, but just a bailout.
if (error.IsLanguageError() &&
(LanguageError::Cast(error).kind() == Report::kBailout)) {
thread()->clear_sticky_error();
}
is_compiled = false;
}
// Reset global isolate state.
thread()->set_deopt_id(prev_deopt_id);
}
return is_compiled;
}
static RawError* PrecompileFunctionHelper(CompilationPipeline* pipeline,
const Function& function,
bool optimized) {
// Check that we optimize, except if the function is not optimizable.
ASSERT(FLAG_precompiled_mode);
ASSERT(!function.IsOptimizable() || optimized);
ASSERT(!function.HasCode());
LongJumpScope jump;
if (setjmp(*jump.Set()) == 0) {
Thread* const thread = Thread::Current();
StackZone stack_zone(thread);
Zone* const zone = stack_zone.GetZone();
const bool trace_compiler =
FLAG_trace_compiler ||
(FLAG_trace_optimizing_compiler && optimized);
Timer per_compile_timer(trace_compiler, "Compilation time");
per_compile_timer.Start();
ParsedFunction* parsed_function = new(zone) ParsedFunction(
thread, Function::ZoneHandle(zone, function.raw()));
if (trace_compiler) {
THR_Print(
"Precompiling %sfunction: '%s' @ token %" Pd ", size %" Pd "\n",
(optimized ? "optimized " : ""),
function.ToFullyQualifiedCString(),
function.token_pos().Pos(),
(function.end_token_pos().Pos() - function.token_pos().Pos()));
}
INC_STAT(thread, num_functions_compiled, 1);
if (optimized) {
INC_STAT(thread, num_functions_optimized, 1);
}
{
HANDLESCOPE(thread);
const int64_t num_tokens_before = STAT_VALUE(thread, num_tokens_consumed);
pipeline->ParseFunction(parsed_function);
const int64_t num_tokens_after = STAT_VALUE(thread, num_tokens_consumed);
INC_STAT(thread,
num_func_tokens_compiled,
num_tokens_after - num_tokens_before);
}
PrecompileParsedFunctionHelper helper(parsed_function, optimized);
const bool success = helper.Compile(pipeline);
if (!success) {
// Encountered error.
Error& error = Error::Handle();
// We got an error during compilation.
error = thread->sticky_error();
thread->clear_sticky_error();
ASSERT(error.IsLanguageError() &&
LanguageError::Cast(error).kind() != Report::kBailout);
return error.raw();
}
per_compile_timer.Stop();
if (trace_compiler && success) {
THR_Print("--> '%s' entry: %#" Px " size: %" Pd " time: %" Pd64 " us\n",
function.ToFullyQualifiedCString(),
Code::Handle(function.CurrentCode()).EntryPoint(),
Code::Handle(function.CurrentCode()).Size(),
per_compile_timer.TotalElapsedTime());
}
if (FLAG_disassemble && FlowGraphPrinter::ShouldPrint(function)) {
Disassembler::DisassembleCode(function, optimized);
} else if (FLAG_disassemble_optimized &&
optimized &&
FlowGraphPrinter::ShouldPrint(function)) {
// TODO(fschneider): Print unoptimized code along with the optimized code.
THR_Print("*** BEGIN CODE\n");
Disassembler::DisassembleCode(function, true);
THR_Print("*** END CODE\n");
}
return Error::null();
} else {
Thread* const thread = Thread::Current();
StackZone stack_zone(thread);
Error& error = Error::Handle();
// We got an error during compilation.
error = thread->sticky_error();
thread->clear_sticky_error();
// Precompilation may encounter compile-time errors.
// Do not attempt to optimize functions that can cause errors.
function.set_is_optimizable(false);
return error.raw();
}
UNREACHABLE();
return Error::null();
}
RawError* Precompiler::CompileFunction(Thread* thread,
const Function& function) {
VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
TIMELINE_FUNCTION_COMPILATION_DURATION(thread, "Function", function);
CompilationPipeline* pipeline =
CompilationPipeline::New(thread->zone(), function);
ASSERT(FLAG_precompiled_mode);
const bool optimized = function.IsOptimizable(); // False for natives.
return PrecompileFunctionHelper(pipeline, function, optimized);
}
#endif // DART_PRECOMPILER
} // namespace dart
|
/******************************************************************************
* Copyright (c) 2011, Michael P. Gerlek (mpg@flaxen.com)
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following
* conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
****************************************************************************/
#ifndef _WIN32
#include <dlfcn.h>
#endif
#include <pdal/plang/Environment.hpp>
#include <pdal/plang/Redirector.hpp>
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#define PY_ARRAY_UNIQUE_SYMBOL PDAL_ARRAY_API
#include <numpy/arrayobject.h>
#include <sstream>
#include <mutex>
#ifdef PDAL_COMPILER_MSVC
# pragma warning(disable: 4127) // conditional expression is constant
#endif
#include <Python.h>
#include <pystate.h>
#undef toupper
#undef tolower
#undef isspace
// See ticket #1010. This function runs when libplang is loaded. It makes
// sure python symbols can be found by extention module .so's since on some
// platforms (notably Ubuntu), they aren't linked with libpython even though
// they depend on it. If a platform doesn't support
// __attribute__ ((constructor)) this does nothing. We'll have to deal with
// those as they come up.
#ifndef _WIN32
__attribute__ ((constructor))
void loadPython()
{
::dlopen(PDAL_PYTHON_LIBRARY, RTLD_LAZY | RTLD_GLOBAL);
}
#endif
// http://www.linuxjournal.com/article/3641
// http://www.codeproject.com/Articles/11805/Embedding-Python-in-C-C-Part-I
// http://stackoverflow.com/questions/6596016/python-threads-in-c
namespace pdal
{
namespace plang
{
static Environment* g_environment=0;
EnvironmentPtr Environment::get()
{
static std::once_flag flag;
auto init = []()
{
g_environment = new Environment();
};
std::call_once(flag, init);
return g_environment;
}
Environment::Environment()
{
// This awfulness is due to the import_array MACRO that returns a value
// in some cases and returns nothing at other times. Defining
// NUMPY_IMPORT_ARRAY_RETVAL to nothing makes it so we don't ever return
// a value. The function needs to be stuck in a function to deal with
// the return.
auto initNumpy = []()
{
#undef NUMPY_IMPORT_ARRAY_RETVAL
#define NUMPY_IMPORT_ARRAY_RETVAL
import_array();
};
PyImport_AppendInittab(const_cast<char*>("redirector"), redirector_init);
Py_Initialize();
initNumpy();
PyImport_ImportModule("redirector");
}
Environment::~Environment()
{
Py_Finalize();
}
void Environment::set_stdout(std::ostream* ostr)
{
m_redirector.set_stdout(ostr);
}
void Environment::reset_stdout()
{
m_redirector.reset_stdout();
}
std::string getTraceback()
{
// get exception info
PyObject *type, *value, *traceback;
PyErr_Fetch(&type, &value, &traceback);
PyErr_NormalizeException(&type, &value, &traceback);
std::ostringstream mssg;
if (traceback)
{
PyObject* tracebackModule;
PyObject* tracebackDictionary;
PyObject* tracebackFunction;
tracebackModule = PyImport_ImportModule("traceback");
if (!tracebackModule)
throw pdal::pdal_error("Unable to load traceback module.");
tracebackDictionary = PyModule_GetDict(tracebackModule);
if (!tracebackDictionary)
throw pdal::pdal_error("Unable to load traceback dictionary.");
tracebackFunction =
PyDict_GetItemString(tracebackDictionary, "format_exception");
if (!tracebackFunction)
throw pdal::pdal_error("Unable to find traceback function.");
if (!PyCallable_Check(tracebackFunction))
throw pdal::pdal_error("Invalid traceback function.");
// create an argument for "format exception"
PyObject* args = PyTuple_New(3);
PyTuple_SetItem(args, 0, type);
PyTuple_SetItem(args, 1, value);
PyTuple_SetItem(args, 2, traceback);
// get a list of string describing what went wrong
PyObject* output = PyObject_CallObject(tracebackFunction, args);
// print error message
int n = PyList_Size(output);
for (int i = 0; i < n; i++)
{
PyObject* l = PyList_GetItem(output, i);
if (!l)
throw pdal::pdal_error("unable to get list item in getTraceback");
PyObject* r = PyObject_Repr(l);
if (!r)
throw pdal::pdal_error("unable to get repr in getTraceback");
Py_ssize_t size;
#if PY_MAJOR_VERSION >= 3
char* d = PyUnicode_AsUTF8AndSize(r, &size);
#else
char* d = PyString_AsString(r);
#endif
mssg << d;
}
// clean up
Py_XDECREF(args);
Py_XDECREF(output);
}
else if (value != NULL)
{
PyObject* r = PyObject_Repr(value);
if (!r)
throw pdal::pdal_error("couldn't make string representation of traceback value");
Py_ssize_t size;
#if PY_MAJOR_VERSION >= 3
char* d = PyUnicode_AsUTF8AndSize(r, &size);
#else
char* d = PyString_AsString(r);
#endif
mssg << d;
}
else
mssg << "unknown error that we are unable to get a traceback for."
"Was it already printed/taken?";
Py_XDECREF(value);
Py_XDECREF(type);
Py_XDECREF(traceback);
return mssg.str();
}
PyObject *fromMetadata(MetadataNode m)
{
std::string name = m.name();
std::string value = m.value();
std::string type = m.type();
std::string description = m.description();
MetadataNodeList children = m.children();
PyObject *submeta = NULL;
if (children.size())
{
submeta = PyList_New(0);
for (MetadataNode& child : children)
PyList_Append(submeta, fromMetadata(child));
}
PyObject *data = PyTuple_New(5);
PyTuple_SetItem(data, 0, PyUnicode_FromString(name.data()));
PyTuple_SetItem(data, 1, PyUnicode_FromString(value.data()));
PyTuple_SetItem(data, 2, PyUnicode_FromString(type.data()));
PyTuple_SetItem(data, 3, PyUnicode_FromString(description.data()));
PyTuple_SetItem(data, 4, submeta);
return data;
}
std::string readPythonString(PyObject* list, Py_ssize_t index)
{
std::stringstream ss;
PyObject* o = PyTuple_GetItem(list, index);
if (!o)
{
std::stringstream oss;
oss << "Unable to get list item number " << index << " for list of length " << PyTuple_Size(list);
throw pdal_error(oss.str());
}
PyObject* r = PyObject_Repr(o);
if (!r)
throw pdal::pdal_error("unable to get repr in readPythonString");
Py_ssize_t size;
#if PY_MAJOR_VERSION >= 3
char* d = PyUnicode_AsUTF8AndSize(r, &size);
#else
char* d = PyString_AsString(r);
#endif
ss << d;
return ss.str();
}
void addMetadata(PyObject *list, MetadataNode m)
{
if (!PyList_Check(list))
return;
for (Py_ssize_t i = 0; i < PyList_Size(list); ++i)
{
PyObject *tuple = PyList_GetItem(list, i);
if (!PyTuple_Check(tuple) || PyTuple_Size(tuple) != 5)
continue;
std::string name = readPythonString(tuple, 0);
std::string value = readPythonString(tuple, 1);
std::string type = readPythonString(tuple, 2);
if (type.empty())
type = Metadata::inferType(value);
std::string description = readPythonString(tuple, 3);
PyObject *submeta = PyTuple_GetItem(tuple, 4);
MetadataNode child = m.addWithType(name, value, type, description);
if (submeta)
addMetadata(submeta, child);
}
}
int Environment::getPythonDataType(Dimension::Type::Enum t)
{
using namespace Dimension;
switch (t)
{
case Type::Float:
return NPY_FLOAT;
case Type::Double:
return NPY_DOUBLE;
case Type::Signed8:
return NPY_BYTE;
case Type::Signed16:
return NPY_SHORT;
case Type::Signed32:
return NPY_INT;
case Type::Signed64:
return NPY_LONGLONG;
case Type::Unsigned8:
return NPY_UBYTE;
case Type::Unsigned16:
return NPY_USHORT;
case Type::Unsigned32:
return NPY_UINT;
case Type::Unsigned64:
return NPY_ULONGLONG;
default:
return -1;
}
assert(0);
return -1;
}
} // namespace plang
} // namespace pdal
Debug for testing.
/******************************************************************************
* Copyright (c) 2011, Michael P. Gerlek (mpg@flaxen.com)
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following
* conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Hobu, Inc. or Flaxen Geo Consulting nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
****************************************************************************/
#ifndef _WIN32
#include <dlfcn.h>
#endif
#include <pdal/plang/Environment.hpp>
#include <pdal/plang/Redirector.hpp>
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#define PY_ARRAY_UNIQUE_SYMBOL PDAL_ARRAY_API
#include <numpy/arrayobject.h>
#include <sstream>
#include <mutex>
#ifdef PDAL_COMPILER_MSVC
# pragma warning(disable: 4127) // conditional expression is constant
#endif
#include <Python.h>
#include <pystate.h>
#undef toupper
#undef tolower
#undef isspace
// See ticket #1010. This function runs when libplang is loaded. It makes
// sure python symbols can be found by extention module .so's since on some
// platforms (notably Ubuntu), they aren't linked with libpython even though
// they depend on it. If a platform doesn't support
// __attribute__ ((constructor)) this does nothing. We'll have to deal with
// those as they come up.
#ifndef _WIN32
__attribute__ ((constructor))
static void loadPython()
{
std::cerr << "Force load python.\n";
::dlopen(PDAL_PYTHON_LIBRARY, RTLD_LAZY | RTLD_GLOBAL);
}
#endif
// http://www.linuxjournal.com/article/3641
// http://www.codeproject.com/Articles/11805/Embedding-Python-in-C-C-Part-I
// http://stackoverflow.com/questions/6596016/python-threads-in-c
namespace pdal
{
namespace plang
{
static Environment* g_environment=0;
EnvironmentPtr Environment::get()
{
static std::once_flag flag;
auto init = []()
{
g_environment = new Environment();
};
std::call_once(flag, init);
return g_environment;
}
Environment::Environment()
{
// This awfulness is due to the import_array MACRO that returns a value
// in some cases and returns nothing at other times. Defining
// NUMPY_IMPORT_ARRAY_RETVAL to nothing makes it so we don't ever return
// a value. The function needs to be stuck in a function to deal with
// the return.
auto initNumpy = []()
{
#undef NUMPY_IMPORT_ARRAY_RETVAL
#define NUMPY_IMPORT_ARRAY_RETVAL
import_array();
};
PyImport_AppendInittab(const_cast<char*>("redirector"), redirector_init);
Py_Initialize();
initNumpy();
PyImport_ImportModule("redirector");
}
Environment::~Environment()
{
Py_Finalize();
}
void Environment::set_stdout(std::ostream* ostr)
{
m_redirector.set_stdout(ostr);
}
void Environment::reset_stdout()
{
m_redirector.reset_stdout();
}
std::string getTraceback()
{
// get exception info
PyObject *type, *value, *traceback;
PyErr_Fetch(&type, &value, &traceback);
PyErr_NormalizeException(&type, &value, &traceback);
std::ostringstream mssg;
if (traceback)
{
PyObject* tracebackModule;
PyObject* tracebackDictionary;
PyObject* tracebackFunction;
tracebackModule = PyImport_ImportModule("traceback");
if (!tracebackModule)
throw pdal::pdal_error("Unable to load traceback module.");
tracebackDictionary = PyModule_GetDict(tracebackModule);
if (!tracebackDictionary)
throw pdal::pdal_error("Unable to load traceback dictionary.");
tracebackFunction =
PyDict_GetItemString(tracebackDictionary, "format_exception");
if (!tracebackFunction)
throw pdal::pdal_error("Unable to find traceback function.");
if (!PyCallable_Check(tracebackFunction))
throw pdal::pdal_error("Invalid traceback function.");
// create an argument for "format exception"
PyObject* args = PyTuple_New(3);
PyTuple_SetItem(args, 0, type);
PyTuple_SetItem(args, 1, value);
PyTuple_SetItem(args, 2, traceback);
// get a list of string describing what went wrong
PyObject* output = PyObject_CallObject(tracebackFunction, args);
// print error message
int n = PyList_Size(output);
for (int i = 0; i < n; i++)
{
PyObject* l = PyList_GetItem(output, i);
if (!l)
throw pdal::pdal_error("unable to get list item in getTraceback");
PyObject* r = PyObject_Repr(l);
if (!r)
throw pdal::pdal_error("unable to get repr in getTraceback");
Py_ssize_t size;
#if PY_MAJOR_VERSION >= 3
char* d = PyUnicode_AsUTF8AndSize(r, &size);
#else
char* d = PyString_AsString(r);
#endif
mssg << d;
}
// clean up
Py_XDECREF(args);
Py_XDECREF(output);
}
else if (value != NULL)
{
PyObject* r = PyObject_Repr(value);
if (!r)
throw pdal::pdal_error("couldn't make string representation of traceback value");
Py_ssize_t size;
#if PY_MAJOR_VERSION >= 3
char* d = PyUnicode_AsUTF8AndSize(r, &size);
#else
char* d = PyString_AsString(r);
#endif
mssg << d;
}
else
mssg << "unknown error that we are unable to get a traceback for."
"Was it already printed/taken?";
Py_XDECREF(value);
Py_XDECREF(type);
Py_XDECREF(traceback);
return mssg.str();
}
PyObject *fromMetadata(MetadataNode m)
{
std::string name = m.name();
std::string value = m.value();
std::string type = m.type();
std::string description = m.description();
MetadataNodeList children = m.children();
PyObject *submeta = NULL;
if (children.size())
{
submeta = PyList_New(0);
for (MetadataNode& child : children)
PyList_Append(submeta, fromMetadata(child));
}
PyObject *data = PyTuple_New(5);
PyTuple_SetItem(data, 0, PyUnicode_FromString(name.data()));
PyTuple_SetItem(data, 1, PyUnicode_FromString(value.data()));
PyTuple_SetItem(data, 2, PyUnicode_FromString(type.data()));
PyTuple_SetItem(data, 3, PyUnicode_FromString(description.data()));
PyTuple_SetItem(data, 4, submeta);
return data;
}
std::string readPythonString(PyObject* list, Py_ssize_t index)
{
std::stringstream ss;
PyObject* o = PyTuple_GetItem(list, index);
if (!o)
{
std::stringstream oss;
oss << "Unable to get list item number " << index << " for list of length " << PyTuple_Size(list);
throw pdal_error(oss.str());
}
PyObject* r = PyObject_Repr(o);
if (!r)
throw pdal::pdal_error("unable to get repr in readPythonString");
Py_ssize_t size;
#if PY_MAJOR_VERSION >= 3
char* d = PyUnicode_AsUTF8AndSize(r, &size);
#else
char* d = PyString_AsString(r);
#endif
ss << d;
return ss.str();
}
void addMetadata(PyObject *list, MetadataNode m)
{
if (!PyList_Check(list))
return;
for (Py_ssize_t i = 0; i < PyList_Size(list); ++i)
{
PyObject *tuple = PyList_GetItem(list, i);
if (!PyTuple_Check(tuple) || PyTuple_Size(tuple) != 5)
continue;
std::string name = readPythonString(tuple, 0);
std::string value = readPythonString(tuple, 1);
std::string type = readPythonString(tuple, 2);
if (type.empty())
type = Metadata::inferType(value);
std::string description = readPythonString(tuple, 3);
PyObject *submeta = PyTuple_GetItem(tuple, 4);
MetadataNode child = m.addWithType(name, value, type, description);
if (submeta)
addMetadata(submeta, child);
}
}
int Environment::getPythonDataType(Dimension::Type::Enum t)
{
using namespace Dimension;
switch (t)
{
case Type::Float:
return NPY_FLOAT;
case Type::Double:
return NPY_DOUBLE;
case Type::Signed8:
return NPY_BYTE;
case Type::Signed16:
return NPY_SHORT;
case Type::Signed32:
return NPY_INT;
case Type::Signed64:
return NPY_LONGLONG;
case Type::Unsigned8:
return NPY_UBYTE;
case Type::Unsigned16:
return NPY_USHORT;
case Type::Unsigned32:
return NPY_UINT;
case Type::Unsigned64:
return NPY_ULONGLONG;
default:
return -1;
}
assert(0);
return -1;
}
} // namespace plang
} // namespace pdal
|
// @(#)root/treeplayer:$Id$
// Author: Axel Naumann, 2011-09-21
/*************************************************************************
* Copyright (C) 1995-2013, Rene Brun and Fons Rademakers and al. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#include "TTreeReader.h"
#include "TChain.h"
#include "TDirectory.h"
#include "TEntryList.h"
#include "TTreeCache.h"
#include "TTreeReaderValue.h"
// clang-format off
/**
\class TTreeReader
\ingroup treeplayer
\brief A simple, robust and fast interface to read values from ROOT colmnar datasets such as TTree, TChain or TNtuple
TTreeReader is associated to TTreeReaderValue and TTreeReaderArray which are handles to concretely
access the information in the dataset.
Example code can be found in
- tutorials/tree/hsimpleReader.C
- tutorials/tree/h1analysisTreeReader.C
- <a href="http://root.cern.ch/gitweb?p=roottest.git;a=tree;f=root/tree/reader;hb=HEAD">This example</a>
You can generate a skeleton of `TTreeReaderValue<T>` and `TTreeReaderArray<T>` declarations
for all of a tree's branches using `TTree::MakeSelector()`.
Roottest contains an
<a href="http://root.cern.ch/gitweb?p=roottest.git;a=tree;f=root/tree/reader;hb=HEAD">example</a>
showing the full power.
A simpler analysis example can be found below: it histograms a function of the px and py branches.
~~~{.cpp}
// A simple TTreeReader use: read data from hsimple.root (written by hsimple.C)
#include "TFile.h
#include "TH1F.h
#include "TTreeReader.h
#include "TTreeReaderValue.h
void hsimpleReader() {
// Create a histogram for the values we read.
TH1F("h1", "ntuple", 100, -4, 4);
// Open the file containing the tree.
TFile *myFile = TFile::Open("$ROOTSYS/tutorials/hsimple.root");
// Create a TTreeReader for the tree, for instance by passing the
// TTree's name and the TDirectory / TFile it is in.
TTreeReader myReader("ntuple", myFile);
// The branch "px" contains floats; access them as myPx.
TTreeReaderValue<Float_t> myPx(myReader, "px");
// The branch "py" contains floats, too; access those as myPy.
TTreeReaderValue<Float_t> myPy(myReader, "py");
// Loop over all entries of the TTree or TChain.
while (myReader.Next()) {
// Just access the data as if myPx and myPy were iterators (note the '*'
// in front of them):
myHist->Fill(*myPx + *myPy);
}
myHist->Draw();
}
~~~
A more complete example including error handling and a few combinations of
TTreeReaderValue and TTreeReaderArray would look like this:
~~~{.cpp}
#include <TFile.h>
#include <TH1.h>
#include <TTreeReader.h>
#include <TTreeReaderValue.h>
#include <TTreeReaderArray.h>
#include "TriggerInfo.h"
#include "Muon.h"
#include "Tau.h"
#include <vector>
#include <iostream>
bool CheckValue(ROOT::Internal::TTreeReaderValueBase& value) {
if (value->GetSetupStatus() < 0) {
std::cerr << "Error " << value->GetSetupStatus()
<< "setting up reader for " << value->GetBranchName() << '\n';
return false;
}
return true;
}
// Analyze the tree "MyTree" in the file passed into the function.
// Returns false in case of errors.
bool analyze(TFile* file) {
// Create a TTreeReader named "MyTree" from the given TDirectory.
// The TTreeReader gives access to the TTree to the TTreeReaderValue and
// TTreeReaderArray objects. It knows the current entry number and knows
// how to iterate through the TTree.
TTreeReader reader("MyTree", file);
// Read a single float value in each tree entries:
TTreeReaderValue<float> weight(reader, "event.weight");
// Read a TriggerInfo object from the tree entries:
TTreeReaderValue<TriggerInfo> triggerInfo(reader, "triggerInfo");
//Read a vector of Muon objects from the tree entries:
TTreeReaderValue<std::vector<Muon>> muons(reader, "muons");
//Read the pT for all jets in the tree entry:
TTreeReaderArray<double> jetPt(reader, "jets.pT");
// Read the taus in the tree entry:
TTreeReaderArray<Tau> taus(reader, "taus");
// Now iterate through the TTree entries and fill a histogram.
TH1F("hist", "TTreeReader example histogram", 10, 0., 100.);
while (reader.Next()) {
if (!CheckValue(weight)) return false;
if (!CheckValue(triggerInfo)) return false;
if (!CheckValue(muons)) return false;
if (!CheckValue(jetPt)) return false;
if (!CheckValue(taus)) return false;
// Access the TriggerInfo object as if it's a pointer.
if (!triggerInfo->hasMuonL1())
continue;
// Ditto for the vector<Muon>.
if (!muons->size())
continue;
// Access the jetPt as an array, whether the TTree stores this as
// a std::vector, std::list, TClonesArray or Jet* C-style array, with
// fixed or variable array size.
if (jetPt.GetSize() < 2 || jetPt[0] < 100)
continue;
// Access the array of taus.
if (!taus.IsEmpty()) {
// Access a float value - need to dereference as TTreeReaderValue
// behaves like an iterator
float currentWeight = *weight;
for (const Tau& tau: taus) {
hist->Fill(tau.eta(), currentWeight);
}
}
} // TTree entry / event loop
}
~~~
*/
// clang-format on
ClassImp(TTreeReader);
using namespace ROOT::Internal;
// Provide some storage for the poor little symbol.
constexpr const char * const TTreeReader::fgEntryStatusText[TTreeReader::kEntryBeyondEnd + 1];
////////////////////////////////////////////////////////////////////////////////
/// Access data from tree.
TTreeReader::TTreeReader(TTree* tree, TEntryList* entryList /*= nullptr*/):
fTree(tree),
fEntryList(entryList)
{
if (!fTree) {
Error("TTreeReader", "TTree is NULL!");
} else {
Initialize();
}
}
////////////////////////////////////////////////////////////////////////////////
/// Access data from the tree called keyname in the directory (e.g. TFile)
/// dir, or the current directory if dir is NULL. If keyname cannot be
/// found, or if it is not a TTree, IsZombie() will return true.
TTreeReader::TTreeReader(const char* keyname, TDirectory* dir, TEntryList* entryList /*= nullptr*/):
fEntryList(entryList)
{
if (!dir) dir = gDirectory;
dir->GetObject(keyname, fTree);
Initialize();
}
////////////////////////////////////////////////////////////////////////////////
/// Tell all value readers that the tree reader does not exist anymore.
TTreeReader::~TTreeReader()
{
for (std::deque<ROOT::Internal::TTreeReaderValueBase*>::const_iterator
i = fValues.begin(), e = fValues.end(); i != e; ++i) {
(*i)->MarkTreeReaderUnavailable();
}
delete fDirector;
}
////////////////////////////////////////////////////////////////////////////////
/// Initialization of the director.
void TTreeReader::Initialize()
{
fEntry = -1;
if (!fTree) {
MakeZombie();
fEntryStatus = kEntryNoTree;
fMostRecentTreeNumber = -1;
return;
}
ResetBit(kZombie);
if (fTree->InheritsFrom(TChain::Class())) {
SetBit(kBitIsChain);
}
fDirector = new ROOT::Internal::TBranchProxyDirector(fTree, -1);
}
////////////////////////////////////////////////////////////////////////////////
/// Set the range of entries to be loaded by `Next()`; end will not be loaded.
///
/// If end <= begin, `end` is ignored (set to `-1`) and only `begin` is used.
/// Example:
///
/// ~~~ {.cpp}
/// reader.SetEntriesRange(3, 5);
/// while (reader.Next()) {
/// // Will load entries 3 and 4.
/// }
/// ~~~
///
/// \param beginEntry The first entry to be loaded by `Next()`.
/// \param endEntry The entry where `Next()` will return kFALSE, not loading it.
TTreeReader::EEntryStatus TTreeReader::SetEntriesRange(Long64_t beginEntry, Long64_t endEntry)
{
if (beginEntry < 0)
return kEntryNotFound;
// Complain if the entries number is larger than the tree's / chain's / entry
// list's number of entries, unless it's a TChain and "max entries" is
// uninitialized (i.e. TTree::kMaxEntries).
if (beginEntry >= GetEntries(false) && !(IsChain() && GetEntries(false) == TTree::kMaxEntries)) {
Error("SetEntriesRange()", "first entry out of range 0..%lld", GetEntries(false));
return kEntryNotFound;
}
if (endEntry > beginEntry)
fEndEntry = endEntry;
else
fEndEntry = -1;
if (beginEntry - 1 < 0)
Restart();
else {
EEntryStatus es = SetEntry(beginEntry - 1);
if (es != kEntryValid) {
Error("SetEntriesRange()", "Error setting first entry %lld: %s",
beginEntry, fgEntryStatusText[(int)es]);
return es;
}
}
fBeginEntry = beginEntry;
return kEntryValid;
}
void TTreeReader::Restart() {
fDirector->SetTree(nullptr);
fDirector->SetReadEntry(-1);
fProxiesSet = false; // we might get more value readers, meaning new proxies.
fEntry = -1;
if (const auto curFile = fTree->GetCurrentFile()) {
if (auto tc = fTree->GetTree()->GetReadCache(curFile, true)) {
tc->DropBranch("*", true);
tc->ResetCache();
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// Returns the number of entries of the TEntryList if one is provided, else
/// of the TTree / TChain, independent of a range set by SetEntriesRange().
///
/// \param force If `IsChain()` and `force`, determines whether all TFiles of
/// this TChain should be opened to determine the exact number of entries
/// of the TChain. If `!IsChain()`, `force` is ignored.
Long64_t TTreeReader::GetEntries(Bool_t force) const {
if (fEntryList)
return fEntryList->GetN();
if (!fTree)
return -1;
if (force)
return fTree->GetEntries();
return fTree->GetEntriesFast();
}
////////////////////////////////////////////////////////////////////////////////
/// Load an entry into the tree, return the status of the read.
/// For chains, entry is the global (i.e. not tree-local) entry number, unless
/// `local` is `true`, in which case `entry` specifies the entry number within
/// the current tree. This is needed for instance for TSelector::Process().
TTreeReader::EEntryStatus TTreeReader::SetEntryBase(Long64_t entry, Bool_t local)
{
if (!fTree || !fDirector) {
fEntryStatus = kEntryNoTree;
fEntry = -1;
return fEntryStatus;
}
if (fTree->GetEntryList() && !TestBit(kBitHaveWarnedAboutEntryListAttachedToTTree)) {
Warning("SetEntryBase()",
"The TTree / TChain has an associated TEntryList. "
"TTreeReader ignores TEntryLists unless you construct the TTreeReader passing a TEntryList.");
SetBit(kBitHaveWarnedAboutEntryListAttachedToTTree);
}
fEntry = entry;
Long64_t entryAfterList = entry;
if (fEntryList) {
if (entry >= fEntryList->GetN()) {
// Passed the end of the chain, Restart() was not called:
// don't try to load entries anymore. Can happen in these cases:
// while (tr.Next()) {something()};
// while (tr.Next()) {somethingelse()}; // should not be calling somethingelse().
fEntryStatus = kEntryNotFound;
return fEntryStatus;
}
if (entry >= 0) entryAfterList = fEntryList->GetEntry(entry);
if (local && IsChain()) {
// Must translate the entry list's entry to the current TTree's entry number.
local = kFALSE;
}
}
if (fProxiesSet && fDirector && fDirector->GetReadEntry() == -1
&& fMostRecentTreeNumber != -1) {
// Passed the end of the chain, Restart() was not called:
// don't try to load entries anymore. Can happen in these cases:
// while (tr.Next()) {something()};
// while (tr.Next()) {somethingelse()}; // should not be calling somethingelse().
fEntryStatus = kEntryNotFound;
return fEntryStatus;
}
Int_t treeNumberBeforeLoadTree = fTree->GetTreeNumber();
TTree* treeToCallLoadOn = local ? fTree->GetTree() : fTree;
Long64_t loadResult = treeToCallLoadOn->LoadTree(entryAfterList);
// ROOT-9628 We cover here the case when:
// - We deal with a TChain
// - The last file is opened
// - The TTree is not correctly loaded
// The system is robust against issues with TTrees associated to the chain
// when they are not at the end of it.
if (loadResult == -3 && TestBit(kBitIsChain) && !fTree->GetTree()) {
Warning("SetEntryBase()",
"There was an issue opening the last file associated to the TChain "
"being processed.");
fEntryStatus = kEntryChainFileError;
return fEntryStatus;
}
if (loadResult == -2) {
fDirector->SetTree(nullptr);
fEntryStatus = kEntryNotFound;
return fEntryStatus;
}
if (fMostRecentTreeNumber != -1 // We are not new-born
&& fMostRecentTreeNumber != treeNumberBeforeLoadTree) {
// This can happen if someone switched trees behind us.
// Likely cause: a TChain::LoadTree() e.g. from TTree::Process().
// This means that "local" should be set!
if (fTree->GetTreeNumber() != treeNumberBeforeLoadTree) {
// we have switched trees again, which means that "local" was not set!
// There are two entities switching trees which is bad.
R__ASSERT(!local && "Logic error - !local but tree number changed?");
Warning("SetEntryBase()",
"The current tree in the TChain %s has changed (e.g. by TTree::Process) "
"even though TTreeReader::SetEntry() was called, which switched the tree "
"again. Did you mean to call TTreeReader::SetLocalEntry()?",
fTree->GetName());
}
}
if (fDirector->GetTree() != fTree->GetTree()
|| fMostRecentTreeNumber != fTree->GetTreeNumber()) {
fDirector->SetTree(fTree->GetTree());
if (fProxiesSet) {
for (auto value: fValues) {
value->NotifyNewTree(fTree->GetTree());
}
}
}
fMostRecentTreeNumber = fTree->GetTreeNumber();
if (!fProxiesSet) {
// Tell readers we now have a tree.
// fValues gets insertions during this loop (when parameterized arrays are read),
// invalidating iterators. Use old-school counting instead.
for (size_t i = 0; i < fValues.size(); ++i) {
ROOT::Internal::TTreeReaderValueBase* reader = fValues[i];
reader->CreateProxy();
if (!reader->GetProxy()){
fEntryStatus = kEntryDictionaryError;
return fEntryStatus;
}
}
// If at least one proxy was there and no error occurred, we assume the proxies to be set.
fProxiesSet = !fValues.empty();
// Now we need to properly set the TTreeCache. We do this in steps:
// 1. We set the entry range according to the entry range of the TTreeReader
// 2. We add to the cache the branches identifying them by the name the user provided
// upon creation of the TTreeReader{Value, Array}s
// 3. We stop the learning phase.
// Operations 1, 2 and 3 need to happen in this order. See: https://sft.its.cern.ch/jira/browse/ROOT-9773?focusedCommentId=87837
if (fProxiesSet) {
const auto curFile = fTree->GetCurrentFile();
if (curFile && fTree->GetTree()->GetReadCache(curFile, true)) {
if (!(-1LL == fEndEntry && 0ULL == fBeginEntry)) {
// We need to avoid to pass -1 as end entry to the SetCacheEntryRange method
const auto lastEntry = (-1LL == fEndEntry) ? fTree->GetEntriesFast() : fEndEntry;
fTree->SetCacheEntryRange(fBeginEntry, lastEntry);
}
for (auto value: fValues) {
fTree->AddBranchToCache(value->GetProxy()->GetBranchName(), true);
}
fTree->StopCacheLearningPhase();
}
}
}
if (fEndEntry >= 0 && entry >= fEndEntry) {
fEntryStatus = kEntryBeyondEnd;
return fEntryStatus;
}
fDirector->SetReadEntry(loadResult);
fEntryStatus = kEntryValid;
return fEntryStatus;
}
////////////////////////////////////////////////////////////////////////////////
/// Set (or update) the which tree to read from. `tree` can be
/// a TTree or a TChain.
void TTreeReader::SetTree(TTree* tree, TEntryList* entryList /*= nullptr*/)
{
fTree = tree;
fEntryList = entryList;
fEntry = -1;
if (fTree) {
ResetBit(kZombie);
if (fTree->InheritsFrom(TChain::Class())) {
SetBit(kBitIsChain);
}
}
if (!fDirector) {
Initialize();
}
else {
fDirector->SetTree(fTree);
fDirector->SetReadEntry(-1);
// Distinguish from end-of-chain case:
fMostRecentTreeNumber = -1;
}
}
////////////////////////////////////////////////////////////////////////////////
/// Set (or update) the which tree to read from, passing the name of a tree in a
/// directory.
///
/// \param keyname - name of the tree in `dir`
/// \param dir - the `TDirectory` to load `keyname` from (or gDirectory if `nullptr`)
/// \param entryList - the `TEntryList` to attach to the `TTreeReader`.
void TTreeReader::SetTree(const char* keyname, TDirectory* dir, TEntryList* entryList /*= nullptr*/)
{
TTree* tree = nullptr;
if (!dir)
dir = gDirectory;
dir->GetObject(keyname, tree);
SetTree(tree, entryList);
}
////////////////////////////////////////////////////////////////////////////////
/// Add a value reader for this tree.
Bool_t TTreeReader::RegisterValueReader(ROOT::Internal::TTreeReaderValueBase* reader)
{
if (fProxiesSet) {
Error("RegisterValueReader",
"Error registering reader for %s: TTreeReaderValue/Array objects must be created before the call to Next() / SetEntry() / SetLocalEntry(), or after TTreeReader::Restart()!",
reader->GetBranchName());
return false;
}
fValues.push_back(reader);
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// Remove a value reader for this tree.
void TTreeReader::DeregisterValueReader(ROOT::Internal::TTreeReaderValueBase* reader)
{
std::deque<ROOT::Internal::TTreeReaderValueBase*>::iterator iReader
= std::find(fValues.begin(), fValues.end(), reader);
if (iReader == fValues.end()) {
Error("DeregisterValueReader", "Cannot find reader of type %s for branch %s", reader->GetDerivedTypeName(), reader->fBranchName.Data());
return;
}
fValues.erase(iReader);
}
fix typo
// @(#)root/treeplayer:$Id$
// Author: Axel Naumann, 2011-09-21
/*************************************************************************
* Copyright (C) 1995-2013, Rene Brun and Fons Rademakers and al. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
#include "TTreeReader.h"
#include "TChain.h"
#include "TDirectory.h"
#include "TEntryList.h"
#include "TTreeCache.h"
#include "TTreeReaderValue.h"
// clang-format off
/**
\class TTreeReader
\ingroup treeplayer
\brief A simple, robust and fast interface to read values from ROOT columnar datasets such as TTree, TChain or TNtuple
TTreeReader is associated to TTreeReaderValue and TTreeReaderArray which are handles to concretely
access the information in the dataset.
Example code can be found in
- tutorials/tree/hsimpleReader.C
- tutorials/tree/h1analysisTreeReader.C
- <a href="http://root.cern.ch/gitweb?p=roottest.git;a=tree;f=root/tree/reader;hb=HEAD">This example</a>
You can generate a skeleton of `TTreeReaderValue<T>` and `TTreeReaderArray<T>` declarations
for all of a tree's branches using `TTree::MakeSelector()`.
Roottest contains an
<a href="http://root.cern.ch/gitweb?p=roottest.git;a=tree;f=root/tree/reader;hb=HEAD">example</a>
showing the full power.
A simpler analysis example can be found below: it histograms a function of the px and py branches.
~~~{.cpp}
// A simple TTreeReader use: read data from hsimple.root (written by hsimple.C)
#include "TFile.h
#include "TH1F.h
#include "TTreeReader.h
#include "TTreeReaderValue.h
void hsimpleReader() {
// Create a histogram for the values we read.
TH1F("h1", "ntuple", 100, -4, 4);
// Open the file containing the tree.
TFile *myFile = TFile::Open("$ROOTSYS/tutorials/hsimple.root");
// Create a TTreeReader for the tree, for instance by passing the
// TTree's name and the TDirectory / TFile it is in.
TTreeReader myReader("ntuple", myFile);
// The branch "px" contains floats; access them as myPx.
TTreeReaderValue<Float_t> myPx(myReader, "px");
// The branch "py" contains floats, too; access those as myPy.
TTreeReaderValue<Float_t> myPy(myReader, "py");
// Loop over all entries of the TTree or TChain.
while (myReader.Next()) {
// Just access the data as if myPx and myPy were iterators (note the '*'
// in front of them):
myHist->Fill(*myPx + *myPy);
}
myHist->Draw();
}
~~~
A more complete example including error handling and a few combinations of
TTreeReaderValue and TTreeReaderArray would look like this:
~~~{.cpp}
#include <TFile.h>
#include <TH1.h>
#include <TTreeReader.h>
#include <TTreeReaderValue.h>
#include <TTreeReaderArray.h>
#include "TriggerInfo.h"
#include "Muon.h"
#include "Tau.h"
#include <vector>
#include <iostream>
bool CheckValue(ROOT::Internal::TTreeReaderValueBase& value) {
if (value->GetSetupStatus() < 0) {
std::cerr << "Error " << value->GetSetupStatus()
<< "setting up reader for " << value->GetBranchName() << '\n';
return false;
}
return true;
}
// Analyze the tree "MyTree" in the file passed into the function.
// Returns false in case of errors.
bool analyze(TFile* file) {
// Create a TTreeReader named "MyTree" from the given TDirectory.
// The TTreeReader gives access to the TTree to the TTreeReaderValue and
// TTreeReaderArray objects. It knows the current entry number and knows
// how to iterate through the TTree.
TTreeReader reader("MyTree", file);
// Read a single float value in each tree entries:
TTreeReaderValue<float> weight(reader, "event.weight");
// Read a TriggerInfo object from the tree entries:
TTreeReaderValue<TriggerInfo> triggerInfo(reader, "triggerInfo");
//Read a vector of Muon objects from the tree entries:
TTreeReaderValue<std::vector<Muon>> muons(reader, "muons");
//Read the pT for all jets in the tree entry:
TTreeReaderArray<double> jetPt(reader, "jets.pT");
// Read the taus in the tree entry:
TTreeReaderArray<Tau> taus(reader, "taus");
// Now iterate through the TTree entries and fill a histogram.
TH1F("hist", "TTreeReader example histogram", 10, 0., 100.);
while (reader.Next()) {
if (!CheckValue(weight)) return false;
if (!CheckValue(triggerInfo)) return false;
if (!CheckValue(muons)) return false;
if (!CheckValue(jetPt)) return false;
if (!CheckValue(taus)) return false;
// Access the TriggerInfo object as if it's a pointer.
if (!triggerInfo->hasMuonL1())
continue;
// Ditto for the vector<Muon>.
if (!muons->size())
continue;
// Access the jetPt as an array, whether the TTree stores this as
// a std::vector, std::list, TClonesArray or Jet* C-style array, with
// fixed or variable array size.
if (jetPt.GetSize() < 2 || jetPt[0] < 100)
continue;
// Access the array of taus.
if (!taus.IsEmpty()) {
// Access a float value - need to dereference as TTreeReaderValue
// behaves like an iterator
float currentWeight = *weight;
for (const Tau& tau: taus) {
hist->Fill(tau.eta(), currentWeight);
}
}
} // TTree entry / event loop
}
~~~
*/
// clang-format on
ClassImp(TTreeReader);
using namespace ROOT::Internal;
// Provide some storage for the poor little symbol.
constexpr const char * const TTreeReader::fgEntryStatusText[TTreeReader::kEntryBeyondEnd + 1];
////////////////////////////////////////////////////////////////////////////////
/// Access data from tree.
TTreeReader::TTreeReader(TTree* tree, TEntryList* entryList /*= nullptr*/):
fTree(tree),
fEntryList(entryList)
{
if (!fTree) {
Error("TTreeReader", "TTree is NULL!");
} else {
Initialize();
}
}
////////////////////////////////////////////////////////////////////////////////
/// Access data from the tree called keyname in the directory (e.g. TFile)
/// dir, or the current directory if dir is NULL. If keyname cannot be
/// found, or if it is not a TTree, IsZombie() will return true.
TTreeReader::TTreeReader(const char* keyname, TDirectory* dir, TEntryList* entryList /*= nullptr*/):
fEntryList(entryList)
{
if (!dir) dir = gDirectory;
dir->GetObject(keyname, fTree);
Initialize();
}
////////////////////////////////////////////////////////////////////////////////
/// Tell all value readers that the tree reader does not exist anymore.
TTreeReader::~TTreeReader()
{
for (std::deque<ROOT::Internal::TTreeReaderValueBase*>::const_iterator
i = fValues.begin(), e = fValues.end(); i != e; ++i) {
(*i)->MarkTreeReaderUnavailable();
}
delete fDirector;
}
////////////////////////////////////////////////////////////////////////////////
/// Initialization of the director.
void TTreeReader::Initialize()
{
fEntry = -1;
if (!fTree) {
MakeZombie();
fEntryStatus = kEntryNoTree;
fMostRecentTreeNumber = -1;
return;
}
ResetBit(kZombie);
if (fTree->InheritsFrom(TChain::Class())) {
SetBit(kBitIsChain);
}
fDirector = new ROOT::Internal::TBranchProxyDirector(fTree, -1);
}
////////////////////////////////////////////////////////////////////////////////
/// Set the range of entries to be loaded by `Next()`; end will not be loaded.
///
/// If end <= begin, `end` is ignored (set to `-1`) and only `begin` is used.
/// Example:
///
/// ~~~ {.cpp}
/// reader.SetEntriesRange(3, 5);
/// while (reader.Next()) {
/// // Will load entries 3 and 4.
/// }
/// ~~~
///
/// \param beginEntry The first entry to be loaded by `Next()`.
/// \param endEntry The entry where `Next()` will return kFALSE, not loading it.
TTreeReader::EEntryStatus TTreeReader::SetEntriesRange(Long64_t beginEntry, Long64_t endEntry)
{
if (beginEntry < 0)
return kEntryNotFound;
// Complain if the entries number is larger than the tree's / chain's / entry
// list's number of entries, unless it's a TChain and "max entries" is
// uninitialized (i.e. TTree::kMaxEntries).
if (beginEntry >= GetEntries(false) && !(IsChain() && GetEntries(false) == TTree::kMaxEntries)) {
Error("SetEntriesRange()", "first entry out of range 0..%lld", GetEntries(false));
return kEntryNotFound;
}
if (endEntry > beginEntry)
fEndEntry = endEntry;
else
fEndEntry = -1;
if (beginEntry - 1 < 0)
Restart();
else {
EEntryStatus es = SetEntry(beginEntry - 1);
if (es != kEntryValid) {
Error("SetEntriesRange()", "Error setting first entry %lld: %s",
beginEntry, fgEntryStatusText[(int)es]);
return es;
}
}
fBeginEntry = beginEntry;
return kEntryValid;
}
void TTreeReader::Restart() {
fDirector->SetTree(nullptr);
fDirector->SetReadEntry(-1);
fProxiesSet = false; // we might get more value readers, meaning new proxies.
fEntry = -1;
if (const auto curFile = fTree->GetCurrentFile()) {
if (auto tc = fTree->GetTree()->GetReadCache(curFile, true)) {
tc->DropBranch("*", true);
tc->ResetCache();
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// Returns the number of entries of the TEntryList if one is provided, else
/// of the TTree / TChain, independent of a range set by SetEntriesRange().
///
/// \param force If `IsChain()` and `force`, determines whether all TFiles of
/// this TChain should be opened to determine the exact number of entries
/// of the TChain. If `!IsChain()`, `force` is ignored.
Long64_t TTreeReader::GetEntries(Bool_t force) const {
if (fEntryList)
return fEntryList->GetN();
if (!fTree)
return -1;
if (force)
return fTree->GetEntries();
return fTree->GetEntriesFast();
}
////////////////////////////////////////////////////////////////////////////////
/// Load an entry into the tree, return the status of the read.
/// For chains, entry is the global (i.e. not tree-local) entry number, unless
/// `local` is `true`, in which case `entry` specifies the entry number within
/// the current tree. This is needed for instance for TSelector::Process().
TTreeReader::EEntryStatus TTreeReader::SetEntryBase(Long64_t entry, Bool_t local)
{
if (!fTree || !fDirector) {
fEntryStatus = kEntryNoTree;
fEntry = -1;
return fEntryStatus;
}
if (fTree->GetEntryList() && !TestBit(kBitHaveWarnedAboutEntryListAttachedToTTree)) {
Warning("SetEntryBase()",
"The TTree / TChain has an associated TEntryList. "
"TTreeReader ignores TEntryLists unless you construct the TTreeReader passing a TEntryList.");
SetBit(kBitHaveWarnedAboutEntryListAttachedToTTree);
}
fEntry = entry;
Long64_t entryAfterList = entry;
if (fEntryList) {
if (entry >= fEntryList->GetN()) {
// Passed the end of the chain, Restart() was not called:
// don't try to load entries anymore. Can happen in these cases:
// while (tr.Next()) {something()};
// while (tr.Next()) {somethingelse()}; // should not be calling somethingelse().
fEntryStatus = kEntryNotFound;
return fEntryStatus;
}
if (entry >= 0) entryAfterList = fEntryList->GetEntry(entry);
if (local && IsChain()) {
// Must translate the entry list's entry to the current TTree's entry number.
local = kFALSE;
}
}
if (fProxiesSet && fDirector && fDirector->GetReadEntry() == -1
&& fMostRecentTreeNumber != -1) {
// Passed the end of the chain, Restart() was not called:
// don't try to load entries anymore. Can happen in these cases:
// while (tr.Next()) {something()};
// while (tr.Next()) {somethingelse()}; // should not be calling somethingelse().
fEntryStatus = kEntryNotFound;
return fEntryStatus;
}
Int_t treeNumberBeforeLoadTree = fTree->GetTreeNumber();
TTree* treeToCallLoadOn = local ? fTree->GetTree() : fTree;
Long64_t loadResult = treeToCallLoadOn->LoadTree(entryAfterList);
// ROOT-9628 We cover here the case when:
// - We deal with a TChain
// - The last file is opened
// - The TTree is not correctly loaded
// The system is robust against issues with TTrees associated to the chain
// when they are not at the end of it.
if (loadResult == -3 && TestBit(kBitIsChain) && !fTree->GetTree()) {
Warning("SetEntryBase()",
"There was an issue opening the last file associated to the TChain "
"being processed.");
fEntryStatus = kEntryChainFileError;
return fEntryStatus;
}
if (loadResult == -2) {
fDirector->SetTree(nullptr);
fEntryStatus = kEntryNotFound;
return fEntryStatus;
}
if (fMostRecentTreeNumber != -1 // We are not new-born
&& fMostRecentTreeNumber != treeNumberBeforeLoadTree) {
// This can happen if someone switched trees behind us.
// Likely cause: a TChain::LoadTree() e.g. from TTree::Process().
// This means that "local" should be set!
if (fTree->GetTreeNumber() != treeNumberBeforeLoadTree) {
// we have switched trees again, which means that "local" was not set!
// There are two entities switching trees which is bad.
R__ASSERT(!local && "Logic error - !local but tree number changed?");
Warning("SetEntryBase()",
"The current tree in the TChain %s has changed (e.g. by TTree::Process) "
"even though TTreeReader::SetEntry() was called, which switched the tree "
"again. Did you mean to call TTreeReader::SetLocalEntry()?",
fTree->GetName());
}
}
if (fDirector->GetTree() != fTree->GetTree()
|| fMostRecentTreeNumber != fTree->GetTreeNumber()) {
fDirector->SetTree(fTree->GetTree());
if (fProxiesSet) {
for (auto value: fValues) {
value->NotifyNewTree(fTree->GetTree());
}
}
}
fMostRecentTreeNumber = fTree->GetTreeNumber();
if (!fProxiesSet) {
// Tell readers we now have a tree.
// fValues gets insertions during this loop (when parameterized arrays are read),
// invalidating iterators. Use old-school counting instead.
for (size_t i = 0; i < fValues.size(); ++i) {
ROOT::Internal::TTreeReaderValueBase* reader = fValues[i];
reader->CreateProxy();
if (!reader->GetProxy()){
fEntryStatus = kEntryDictionaryError;
return fEntryStatus;
}
}
// If at least one proxy was there and no error occurred, we assume the proxies to be set.
fProxiesSet = !fValues.empty();
// Now we need to properly set the TTreeCache. We do this in steps:
// 1. We set the entry range according to the entry range of the TTreeReader
// 2. We add to the cache the branches identifying them by the name the user provided
// upon creation of the TTreeReader{Value, Array}s
// 3. We stop the learning phase.
// Operations 1, 2 and 3 need to happen in this order. See: https://sft.its.cern.ch/jira/browse/ROOT-9773?focusedCommentId=87837
if (fProxiesSet) {
const auto curFile = fTree->GetCurrentFile();
if (curFile && fTree->GetTree()->GetReadCache(curFile, true)) {
if (!(-1LL == fEndEntry && 0ULL == fBeginEntry)) {
// We need to avoid to pass -1 as end entry to the SetCacheEntryRange method
const auto lastEntry = (-1LL == fEndEntry) ? fTree->GetEntriesFast() : fEndEntry;
fTree->SetCacheEntryRange(fBeginEntry, lastEntry);
}
for (auto value: fValues) {
fTree->AddBranchToCache(value->GetProxy()->GetBranchName(), true);
}
fTree->StopCacheLearningPhase();
}
}
}
if (fEndEntry >= 0 && entry >= fEndEntry) {
fEntryStatus = kEntryBeyondEnd;
return fEntryStatus;
}
fDirector->SetReadEntry(loadResult);
fEntryStatus = kEntryValid;
return fEntryStatus;
}
////////////////////////////////////////////////////////////////////////////////
/// Set (or update) the which tree to read from. `tree` can be
/// a TTree or a TChain.
void TTreeReader::SetTree(TTree* tree, TEntryList* entryList /*= nullptr*/)
{
fTree = tree;
fEntryList = entryList;
fEntry = -1;
if (fTree) {
ResetBit(kZombie);
if (fTree->InheritsFrom(TChain::Class())) {
SetBit(kBitIsChain);
}
}
if (!fDirector) {
Initialize();
}
else {
fDirector->SetTree(fTree);
fDirector->SetReadEntry(-1);
// Distinguish from end-of-chain case:
fMostRecentTreeNumber = -1;
}
}
////////////////////////////////////////////////////////////////////////////////
/// Set (or update) the which tree to read from, passing the name of a tree in a
/// directory.
///
/// \param keyname - name of the tree in `dir`
/// \param dir - the `TDirectory` to load `keyname` from (or gDirectory if `nullptr`)
/// \param entryList - the `TEntryList` to attach to the `TTreeReader`.
void TTreeReader::SetTree(const char* keyname, TDirectory* dir, TEntryList* entryList /*= nullptr*/)
{
TTree* tree = nullptr;
if (!dir)
dir = gDirectory;
dir->GetObject(keyname, tree);
SetTree(tree, entryList);
}
////////////////////////////////////////////////////////////////////////////////
/// Add a value reader for this tree.
Bool_t TTreeReader::RegisterValueReader(ROOT::Internal::TTreeReaderValueBase* reader)
{
if (fProxiesSet) {
Error("RegisterValueReader",
"Error registering reader for %s: TTreeReaderValue/Array objects must be created before the call to Next() / SetEntry() / SetLocalEntry(), or after TTreeReader::Restart()!",
reader->GetBranchName());
return false;
}
fValues.push_back(reader);
return true;
}
////////////////////////////////////////////////////////////////////////////////
/// Remove a value reader for this tree.
void TTreeReader::DeregisterValueReader(ROOT::Internal::TTreeReaderValueBase* reader)
{
std::deque<ROOT::Internal::TTreeReaderValueBase*>::iterator iReader
= std::find(fValues.begin(), fValues.end(), reader);
if (iReader == fValues.end()) {
Error("DeregisterValueReader", "Cannot find reader of type %s for branch %s", reader->GetDerivedTypeName(), reader->fBranchName.Data());
return;
}
fValues.erase(iReader);
}
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream> // cout, endl
#include <fstream> // fstream
#include <vector>
#include <string>
#include <algorithm> // copy
#include <iterator> // ostream_operator
#include <ctime>
#include <map>
#include <boost/math/constants/constants.hpp>
#include <boost/assign/std/vector.hpp>
#include <boost/tokenizer.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/normal_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include "DateTime.h"
using namespace std;
using namespace boost;
using namespace boost::numeric::ublas;
typedef boost::numeric::ublas::vector<double> VectorD;
typedef boost::numeric::ublas::matrix<double> MatrixD;
class State;
void MainLoop(State& state);
void SaveResults(const std::vector<State>& samples);
void SaveMatrix(const MatrixD& M, std::string filename);
void SetaRange(State& state);
void SetCrpParameterRanges(State& state);
void SetMuBetaRanges(State& state);
MatrixD Concat(const MatrixD& M1, const MatrixD& M2);
void Add(MatrixD& M , double val);
void Print(const MatrixD& M, const std::string msg);
void PrintV(const std::vector<double>& V, const std::string msg);
void LoadData(std::string file, MatrixD&);
MatrixD linspace(double x1, double x2, int num_elements);
MatrixD ones(int nrows, int ncols);
MatrixD zeros(int nrows, int ncols);
MatrixD init_matrix(int nrows, int ncols, double vals);
double sum(const MatrixD& M);
MatrixD cumsum(const MatrixD& M, int dim = 2);
MatrixD cumsum2(const std::vector<double>& V);
double mean(const MatrixD& M);
int GetFirstIndex(const MatrixD& M1, double r);
int length(const MatrixD& M);
MatrixD unique(const MatrixD& M);
int CountInstances(const MatrixD& M, int val);
MatrixD StripZeros(const MatrixD& M);
MatrixD gammaln(const MatrixD M);
MatrixD Exp(const MatrixD& M);
MatrixD init_matrix_mti(int start, int end);
MatrixD setdiff(const MatrixD& M1 , const MatrixD& M2);
MatrixD get_row(const MatrixD M, int i);
MatrixD find_indexes(const MatrixD M, int val);
////////////////////////////////////////////////
// utility function for use with running in gdb
double get_element(MatrixD M, int i, int j);
///////////////////////////////////////////////////////
// functions from m file
MatrixD sample_partition(int n, double gamma);
State drawSample(State& state, int lag);
State sampleHyperParams(State& state);
State sampleKinds(State& state);
State sampleCategories(State& state);
State sampleCategoriesK(State& state, int K, int O);
double crp(const MatrixD& cats, double gamma);
double prob_of_partition_via_counts(MatrixD& ns, double gama);
int chooseState(const MatrixD& logP);
double logsumexp(const MatrixD& a , int dim);
void jumpParam(State& state, int f, double& ng_mu, double& NG_a,
double& NG_b, double& NG_k);
double NG(const MatrixD& data, double mu0, double k0, double a0, double b0);
double sampleMu(const State& state, int f, const MatrixD c, int thisK);
double sampleA(const State& state, int f, const MatrixD c, int thisK);
double sampleB(const State& state, int f, const MatrixD c, int thisK);
double sampleK(const State& state, int f, const MatrixD c, int thisK);
double scoreFeature(State& state, double f);
double scoreObject(State& state, int K , int O);
double NG_cat(const MatrixD& data, double newData, double mu0, double k0, double a0, double b0);
class RandomNumberGen
{
public:
RandomNumberGen() : _engine(std::time(0)), _dist(_engine)
{
}
//////////////////////////////////
// return a random real between
// 0 and 1 with uniform dist
double next()
{
return _dist();
}
//////////////////////////////
// return a random int bewteen
// zero and max - 1 with uniform
// dist if called with same max
int nexti(int max)
{
double D = (double)max;
return (int)std::floor((next() * D));
}
protected:
// Mersenne Twister
boost::mt19937 _engine;
// uniform Distribution
boost::uniform_01<boost::mt19937> _dist;
};
class State
{
public:
State() {}
~State() {}
int F;
int O;
MatrixD f;
MatrixD o;
MatrixD paramPrior;
MatrixD cumParamPrior;
MatrixD paramRange;
MatrixD crpKRange;
MatrixD crpCRange;
MatrixD kRange;
MatrixD aRange;
MatrixD muRange;
MatrixD bRange;
double crpPriorK;
double crpPriorC;
MatrixD NG_a;
MatrixD NG_k;
MatrixD NG_b;
MatrixD NG_mu;
MatrixD data;
};
class GlobalParameters
{
public:
GlobalParameters() : PI(boost::math::constants::pi<double>())
{
}
const double PI;
// set some initial vars
int nChains;
int nSamples;
int burnIn;
int lag;
int bins;
string dataFile;
RandomNumberGen Rand;
};
GlobalParameters GP;
int main(int argc, char** argv)
{
using namespace boost::assign;
// set some initial vars
GP.nChains = 10;
GP.nSamples = 100;
GP.burnIn = 10;
GP.lag = 10;
GP.bins = 31;
GP.dataFile = "SynData2";
State state;
// load data file
LoadData(GP.dataFile + ".csv", state.data);
// num cols
state.F = state.data.size2();
// num rows
state.O = state.data.size1();
// parameters
MatrixD x = linspace(0.03, 0.97, GP.bins);
state.paramPrior = ones(1, x.size2());
state.paramPrior = state.paramPrior / sum(state.paramPrior);
state.cumParamPrior = cumsum(state.paramPrior);
MatrixD y = -x + ones(1, x.size2());
state.paramRange = element_div(x, y);
// set CRP parameter ranges
SetCrpParameterRanges(state);
// set k parameter range
state.kRange = state.crpCRange;
// set 'a' range to n/2
SetaRange(state);
// set mu and beta ranges
SetMuBetaRanges(state);
MainLoop(state);
return 0;
}
void MainLoop(State& state)
{
std::vector<State> samples;
int nc = 1;
for(; nc <= GP.nChains; nc++)
{
cout<< "nc = " << nc << endl;
// initialize parameters randomly
int index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.crpPriorK = state.crpKRange(0,index);
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.crpPriorC = state.crpCRange(0,index);
int i;
state.NG_a.resize(1,state.F);
state.NG_k.resize(1,state.F);
state.NG_b.resize(1,state.F);
state.NG_mu.resize(1,state.F);
for(i = 0; i < state.F; i++)
{
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.NG_a(0,i) = state.aRange(0, index);
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.NG_k(0,i) = state.kRange(0, index);
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.NG_b(0,i) = state.bRange(i, index);
index = GP.Rand.nexti(state.muRange.size2());
state.NG_mu(0,i) = state.muRange(i, index);
}
// initialize state
// state.f stores a partition of features; each element is the
// corresponding kind the feature is assigned to. It is an
// integer array of size 1 x state.F
state.f = sample_partition(state.F, state.crpPriorK);
//state.o stores a partition of objects for each category of
// features. It is an integer matrix of size kinds x state.O where
// kinds = max(staet.f).
int max = (int)*std::max_element(state.f.begin2(), state.f.end2());
state.o.resize(max, state.O);
for(i = 0; i < max; i++)
{
MatrixD Opart = sample_partition(state.O, state.crpPriorC);
project(state.o, range(i, i+1), range(0, Opart.size2())) = Opart;
}
// runModel
Timer T(true);
// burn-in
samples.push_back(drawSample(state, GP.burnIn));
// samples{length(samples)+1} = drawSample(state, burnIn);
cout <<" t1 = " << T.GetElapsed() << endl;
// storing MCMC samples
int ns;
for(ns=2; ns <= GP.nSamples; ns++)
{
// only store every 'lag' samples
cout << "ns = " << ns << endl;
samples.push_back(drawSample(samples[samples.size() - 1], GP.lag));
cout << "t2 = " << T.GetElapsed() << endl;
}
}
SaveResults(samples);
}
void SaveResults(const std::vector<State>& samples)
{
string filename = "crossCatNG_" + GP.dataFile + " (" + DateTime::GetDateTimeStr() + ")";
ofstream out(filename.c_str());
if(!out)
{
cout << "Cannot open file.\n";
return;
}
out << "nChains = " << GP.nChains << endl;
out << "nSamples = " << GP.nSamples << endl;
out << "burnIn = " << GP.burnIn << endl;
out << "lag = " << GP.lag << endl;
out << endl;
int i;
for(i = 0; i < samples.size() ;i++)
{
State state = samples[i];
out << "State"<<i<<endl;
out << "F = " << state.F << endl;
out << "O = " << state.O << endl;
out << "f = " << state.f << endl;
out << "o = " << state.o << endl;
out << "paramPrior = " << state.paramPrior << endl;
out << "cumParamPrior = " << state.cumParamPrior << endl;
out << "paramRange = " << state.paramRange << endl;
out << "crpKRange = " << state.crpKRange << endl;
out << "crpCRange = " << state.crpCRange << endl;
out << "kRange = " << state.kRange << endl;
out << "aRange = " << state.aRange << endl;
out << "muRange = " << state.muRange << endl;
out << "bRange = " << state.bRange << endl;
out << "crpPriorK = " << state.crpPriorK << endl;
out << "crpPriorC = " << state.crpPriorC << endl;
out << "NG_a = " << state.NG_a << endl;
out << "NG_k = " << state.NG_k << endl;
out << "NG_b = " << state.NG_b << endl;
out << "NG_mu = " << state.NG_mu << endl;
out << endl << endl;
}
out.close();
}
State drawSample(State& state, int lag)
{
int i;
for(i = 0; i < lag ; i++)
{
cout << i << endl;
//scoreState(state)
State oldstate = state;
// sample hyper parameters
//cout << "SampleHyperParams" << endl;
state = sampleHyperParams(state);
// sample kinds
//cout << "sampleKinds"<<endl;
if (state.F > 1)
{
//cout << "sampleKinds"<<endl;
state = sampleKinds(state);
}
//sample categories
//cout<<"sampleCategories"<<endl;
state = sampleCategories(state);
}
return state;
}
State sampleHyperParams(State& state)
{
// crpPrior kinds
int len = length(state.crpKRange);
MatrixD logP = zeros(1,len);
int i;
for(i = 0 ; i < len; i++)
{
state.crpPriorK = state.crpKRange(0,i); // assuming uniform prior
logP(0,i) = crp(state.f, state.crpPriorK); // only need to look at kinds
}
// choose state
int index = chooseState(logP); // normalize to probability distribution then take a sample
state.crpPriorK = state.crpKRange(0,index); // 'this' denotes the particular sample drawn
// crpPrior categories
logP = zeros(1,length(state.crpCRange));
int l = length(state.crpCRange);
for(i = 0; i < l; i++)
{
state.crpPriorC = state.crpCRange(0,i);
MatrixD u = unique(state.f);
//Print(state.f, "state.f");
//Print(u, "u");
int j;
for (j=0; j < u.size2(); j++)
{
// DGREEN : subtract 1 for c++ indexing
int k = u(0,j) - 1;
if(k < 0)
{
Print(state.f, "state.f");
Print(u, "u");
exit(0);
}
MatrixD M = project(state.o, range(k, k+1), range(0, state.o.size2()));
logP(0,i) = logP(0,i) + crp(M, state.crpPriorC); // only need to look at categories
}
}
// choose state
index = chooseState(logP);
state.crpPriorC = state.crpCRange(0,index);
// sample feature params
int f;
double NG_mu, NG_a, NG_b, NG_k;
for(f = 0; f < state.F; f++)
{
jumpParam(state, f, NG_mu, NG_a, NG_b, NG_k);
state.NG_a(0,f) = NG_a;
state.NG_b(0,f) = NG_b;
state.NG_k(0,f) = NG_k;
state.NG_mu(0,f) = NG_mu;
}
return state;
}
void jumpParam(State& state, int f, double& NG_mu, double& NG_a,
double& NG_b, double& NG_k)
{
// DGREEN : adjust for c++ indexing
double thisK = state.f(0,f) - 1; // the feature category (view) associated with f
MatrixD M;
M = project(state.o, range(thisK, thisK+1) , range(0, state.o.size2()));
MatrixD c = unique(M); // object category assignment for thisK (view)
NG_mu = sampleMu(state, f, c, thisK);
NG_a = sampleA(state, f, c, thisK);
NG_b = sampleB(state, f, c, thisK);
NG_k = sampleK(state, f, c, thisK);
}
double sampleMu(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.muRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.muRange(f,i), state.NG_k(0,f),
state.NG_a(0,f), state.NG_b(0,f));
}
}
// choose state
int s = chooseState(logP);
double NG_mu = state.muRange(f,s);
return NG_mu;
}
double sampleK(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.kRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.NG_mu(0,f), state.kRange(0,i),
state.NG_a(0,f), state.NG_b(0,f));
logP(0,i) = logP(0, i) + log(state.paramPrior(0,i));
}
}
// choose state
int s = chooseState(logP);
double NG_k = state.kRange(0,s) + 1.0;
return NG_k;
}
double sampleA(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.aRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.NG_mu(0,f), state.NG_k(0,f),
state.aRange(0,i), state.NG_b(0,f));
logP(0,i) = logP(0, i) + log(state.paramPrior(0,i));
}
}
// choose state
int s = chooseState(logP);
double NG_a = state.aRange(0,s);
return NG_a;
}
double sampleB(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.bRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.NG_mu(0,f), state.NG_k(0,f),
state.NG_a(0,f), state.bRange(f,i));
logP(0,i) = logP(0, i) + log(state.paramPrior(0,i)) ;
}
}
// choose state
int s = chooseState(logP);
double NG_b = state.bRange(f,s);
return NG_b;
}
// the probability of data, given the priors under the normal-normal-gamma
// model
// this is based on kevin murphy's cheat sheet (NG.pdf)
// data are assumed to be a vector
// mu0, k0, a0, b0 are hyperparameters
double NG(const MatrixD& data, double mu0, double k0, double a0, double b0)
{
double len = (double)length(data);
double meanData = sum(data) / len;
// muN = (k0.*mu0 + len.*meanData) ./ (k0+len);
double kN = k0 + len;
double aN = a0 + len / 2.0;
MatrixD diff1 = data;
Add(diff1, -meanData);
double diff2 = meanData - mu0;
MatrixD M = element_prod(diff1, diff1);
double bN = b0 + 0.5 * sum(M) + (k0*len*(diff2*diff2)) / (2.0*(k0+len));
double logProb = lgamma(aN) - lgamma(a0) +
log(b0) * a0 - log(bN) * aN +
log( (k0/kN) ) * 0.5 +
log( (2.0 * GP.PI) ) *(-len/2.0);
return logProb;
}
// Given unnormalized log probabilities, return a random sample
int chooseState(const MatrixD& logP)
{
MatrixD M = logP;
Add(M, -logsumexp(M,2));
MatrixD prob = Exp(M); // normalize to 1 given log-prob
MatrixD cumprob = cumsum(prob); // CDF
// find the first entry > rand
double rand = GP.Rand.next();
int i, result = 0;
for(i = 0; i < cumprob.size2(); i++)
{
if(cumprob(0,i) > rand)
{
result = i;
break;
}
}
return result;
}
/////////////////////////////////////////////////////////////////////
// Returns log(sum(exp(a),dim)) while avoiding numerical underflow.
// logsumexp(a, 2) will sum across columns instead of rows
// (ASSUMES row vector for now) users dim spec overridden
double logsumexp(const MatrixD& a , int dim)
{
MatrixD M = a;
dim = 2;
// subtract the largest in each column
double y = *std::max_element(M.begin2(), M.end2());
Add(M, -y);
double res = y + log(sum(Exp(M)));
return res;
}
//////////////////////////////////
// return matrix that applies
// exp operation on each element
MatrixD Exp(const MatrixD& M)
{
int i,j;
int m = M.size1();
int n = M.size2();
MatrixD result(m,n);
for(i=0;i < m; i++)
{
for(j=0; j < n; j++)
{
result(i,j) = ::exp(M(i,j));
}
}
return result;
}
////////////////////////////////////////////////////////////////////
// this includes gibbs moves on features, and M-H move to propose new
// kinds
State sampleKinds(State& state)
{
int f;
for(f=0 ; f < state.F ; f++)
{
MatrixD k = unique(state.f);
// first gibbs (only makes sense if there is more than one feature
// in this kind, and there is more than one kind)
if((CountInstances(state.f,state.f(0,f)) > 1) && (length(k) > 1))
{
std::vector<double> logP;
int j,K;
int len_k = k.size2();
for(j=0 ; j < len_k ; j++)
{
K = k(0,j);
if(K == 0)
{
cout<< "ERROR : K == 0" <<endl;
}
state.f(0,f) = K;
// crp
int sumF = CountInstances(state.f, K);
if(sumF > 1)
{
double temp = (double)sumF - 1.0;
temp = temp / (state.F - 1 + state.crpPriorK);
logP.push_back(log(temp));
}
else
{
logP.push_back(log(state.crpPriorK / (state.F - 1 + state.crpPriorK)));
}
logP[logP.size() - 1] += scoreFeature(state, f);
}
// create a matrix from logP
MatrixD logP_M(1, logP.size());
for(j=0; j < logP.size() ; j++)
{
logP_M(0,j) = logP[j];
}
int s = chooseState(logP_M);
int temp = k(0,s);
if(temp == 0)
{
cout << "ERROR temp = 0"<<endl;
}
state.f(0,f) = k(0,s);
}
// then MH choose new v old
double cut = 0.5; // percent new
State oldState = state;
bool newOld = (GP.Rand.next() > cut);
if( (length(k) == 1) && newOld)
{
continue;
}
double a;
if(!newOld) // new
{
// cout<< "new" << endl;
double logP_1, logP_2;
// sample partition
MatrixD M1 = init_matrix_mti(1, state.F + 1);
MatrixD M2 = setdiff(M1, k);
// newK gets first element
int newK = M2(0,0);
if(newK == 0)
{
cout<< "ERROR : newK = 0" << endl;
}
state.f(0,f) = newK;
// add new row to state.o if you have to
if(newK > state.o.size1())
{
MatrixD temp(newK, state.o.size2());
project(temp, range(0, newK - 1), range(0,state.o.size2())) = state.o;
state.o = temp;
}
project(state.o, range(newK-1, newK), range(0,state.o.size2())) = sample_partition(state.O, state.crpPriorC);
// score new and score old
MatrixD M3 = project(state.o, range(newK-1, newK) , range(0, state.o.size2()));
logP_1 = scoreFeature(state, f) + // score feature
log( state.crpPriorK / (double)(state.F - 1 + state.crpPriorK)) + // new kind
crp(M3, state.crpPriorC); // new categories
double d1 = (double)CountInstances(oldState.f, oldState.f(0,f)) - 1.0;
logP_2 = scoreFeature(oldState, f) + // score feature
log( d1 / (double)(oldState.F - 1 + oldState.crpPriorK)); // new kind
// M-H (t+1 -> t / t -> t+1)
double jump_1, jump_2;
if(CountInstances(oldState.f, oldState.f(0,f)) == 1) // deal with single feature kinds
{
// t + 1 -> t prob of new , prob of choosing cat t
MatrixD M1 = project(oldState.o, range(oldState.f(0,f) - 1, oldState.f(0,f)) ,
range(0, oldState.o.size2()));
jump_1 = log(cut) + crp(M1, state.crpPriorC);
// t -> t+1: prob of new, prob of choosing cat t+1
M1 = project(state.o, range(state.f(0,f) - 1, state.f(0,f)) ,
range(0, state.o.size2()));
jump_2 = log(cut) - crp(M1, state.crpPriorC);
}
else
{
// t+1 -> t: prob of old, prob of choosing kind @ t+1
jump_1 = log((1.0-cut)*(1.0/(double)length(unique(state.f))));
// t -> t+1: prob of new, prob of choosing cat t+1
MatrixD M1 = project(state.o, range(newK-1, newK) , range(0, state.o.size2()));
jump_2 = log(cut) + crp(M1,state.crpPriorC);
}
a = logP_1 - logP_2 + jump_1 - jump_2;
}
else // old
{
// from 1 to length(k)
int newK = 1 + GP.Rand.nexti(length(k));
if(newK == state.f(0,f))
{
continue;
}
double logP_1, logP_2;
double temp = (double)(CountInstances(oldState.f, oldState.f(0,f)) - 1);
logP_2 = scoreFeature(oldState,f) +
log( temp / (double)(oldState.F - 1 + oldState.crpPriorK) );
if(newK == 0)
{
cout<< "ERROR : newK == 0"<<endl;
}
state.f(0,f) = newK;
temp = (double)(CountInstances(state.f, state.f(0,f)));
logP_1 = scoreFeature(state,f) +
log( temp / (double)(state.F - 1 + state.crpPriorK) ) ;
double jump_1, jump_2;
// M-H transition (t+1 -> t / t -> t+1)
if(CountInstances(oldState.f, oldState.f(0,f)) == 1) // single feature kind
{
// t+1 -> t: prob of new, prob of choosing cat t
MatrixD M1 = project(oldState.o, range(oldState.f(0,f) - 1, oldState.f(0,f)),
range(0, oldState.o.size2()));
jump_1 = log(cut) + crp(M1, state.crpPriorC);
// t -> t+1: prob of old, prob of choosing kind @ t
jump_2 = log((1.0-cut) * (1.0/ (double)(length(unique(oldState.f)))));
a = logP_1 - logP_2 + jump_1 - jump_2;
}
else
{
// t+1 -> t: prob of old, prob of choosing kind (same # kinds)
jump_1 = 0;
// t -> t+1: prob of old, prob of choosing kind (same # kinds)
jump_2 = 0;
a = logP_1 - logP_2 + jump_1 - jump_2;
}
}
a = exp(a);
if( a > GP.Rand.next())
{
// state is adopted
}
else
{
// return to old state
state = oldState;
}
}
return state;
}
State sampleCategories(State& state)
{
MatrixD k = unique(state.f);
int i,O;
for(i=0;i < k.size2() ; i++)
{
// DGREEN : adjust K or c++ indexing
int K = k(0,i) - 1;
for(O=0; O < state.O; O++)
{
state = sampleCategoriesK(state, K, O);
}
}
return state;
}
// this executes gibbs sampling for a given kind
//
// K: (int) feature category (view) label
// O: (int) object index
State sampleCategoriesK(State& state, int K, int O)
{
MatrixD M1 = project(state.o, range(K, K+1), range(0, state.o.size2()));
MatrixD C = unique(M1);
// choose a label for new category
MatrixD M2 = init_matrix_mti(1, state.O);
MatrixD empty = setdiff(M2, C);
int max = *std::max_element(C.begin2(), C.end2());
if((empty.size2() == 0) && (max == state.O))
{
// do nothing
}
else
{
C = Concat(C, project(empty, range(0,1), range(0, 1)));
}
MatrixD logP(1, C.size2());
int i;
for(i = 0 ; i < C.size2(); i++)
{
int c = C(0,i);
state.o(K,O) = c;
// cout << "scoreObject" << endl;
logP(0,i) = scoreObject(state, K, O);
}
// choose state
int s = chooseState(logP);
state.o(K,O) = C(0,s);
return state;
}
/////////////////////////////////////////////////////////////////
// scores an object in a category. two parts: crp and likelihood
//
// K: (int) feature category (view) label
// O: (int) object index
double scoreObject(State& state, int K , int O)
{
// find all the indices in state.f where the element == K
// features corresponding to this view K
std::vector<int> theseF;
int i,j;
for(i = 0; i < state.f.size2(); i++)
{
if(state.f(0,i) == K+1) // DEBUG
{
theseF.push_back(i);
}
}
// crp
double logP;
MatrixD M1 = project(state.o, range(K, K+1), range(0, state.o.size2()));
int sumO = CountInstances(M1, state.o(K,O));
if(sumO > 1)
{
logP = log( ((double)sumO - 1.0) / ((double)state.O - 1 + state.crpPriorC));
}
else
{
logP = log( ( state.crpPriorC / ((double)state.O - 1.0 + state.crpPriorC)));
}
// score likelihood of data
M1 = get_row(state.o, K);
MatrixD theseData = find_indexes(M1, state.o(K,O));
theseData(0,O) = 0; // eliminate this object
for(i=0; i < theseF.size(); i++)
{
int f = theseF[i];
std::vector<double> V;
for(j=0;j < theseData.size2(); j++)
{
if((int)theseData(0,j) == 1)
{
V.push_back(state.data(j,f));
}
}
MatrixD M2(1, V.size());
for(j=0;j<V.size();j++)
{
M2(0,j) = V[j];
}
logP = logP + NG_cat(M2, state.data(O,f), state.NG_mu(0,f),
state.NG_k(0,f), state.NG_a(0,f), state.NG_b(0,f));
}
return logP;
}
/////////////////////////////////////////////////////////////////
// probability of a datum given priors and other data
//
// data: column data
// newData: real
// this is based on kevin murphy's cheat sheet (NG.pdf)
// data are assumed to be a vector
// mu0, k0, a0, b0 are hyperparameters
// NOTE: this version is for the gibbs sampler for categories
double NG_cat(const MatrixD& data, double newData, double mu0, double k0, double a0, double b0)
{
// this is updating based on old data
double len, meanData;
double logProb;
if(data.size2() == 0)
{
// do nothing
}
else
{
// NOTE: this could be cached
double len = (double)length(data);
double meanData = sum(data) / len;
mu0 = ((k0 * mu0) + (len * meanData)) / (k0 + len);
k0 = k0 + len;
a0 = a0 + len / 2.0;
MatrixD diff1 = data;
Add(diff1, -meanData);
double diff2 = meanData - mu0;
b0 = b0 + 0.5 * sum(element_prod(diff1,diff1)) +
(k0*len*(diff2*diff2)) / (2.0 * (k0 + len));
}
// this is always a scaler
len = 1.0; //(double)length(newData);
meanData = newData;
// now update with new data
// muN = (k0.*mu0 + len.*meanData) ./ (k0+len);
double kN = k0 + len;
double aN = a0 + len/2.0;
double newdiff1 = 0;
double newdiff2 = meanData - mu0;
double bN = b0 + 0.5 * (newdiff1 * newdiff1) + (k0 * len * (newdiff2 * newdiff2)) / (2.0 * (k0 + len));
logProb = lgamma(aN) - lgamma(a0) + log(b0) * a0 - log(bN) * aN +
log((k0/kN)) * 0.5 + log( (2.0 * GP.PI) ) * (-len/2.0);
return logProb;
}
////////////////////////////////////////////////////////
// return a binary array same size as M with 0 or 1
// in element (i,j) indicating M1(i,j) == val
MatrixD find_indexes(const MatrixD M, int val)
{
MatrixD M2 = zeros(M.size1(), M.size2());
int i,j;
for(i=0; i < M2.size1() ; i++)
{
for(j=0; j < M2.size2() ; j++)
{
int m = (int)M(i,j);
if(m == val)
{
M2(i,j) = 1;
}
}
}
return M2;
}
/////////////////////////////////////////////////////
// return a new 1 x n matrix that is the nth row of M
MatrixD get_row(const MatrixD M, int i)
{
return project(M, range(i, i+1) , range(0, M.size2()));
}
// assume column vectors , vals will be treated as
// integers find M1's not in M2 , return sorted
MatrixD setdiff(const MatrixD& M1, const MatrixD& M2)
{
int i,j;
int sz1 = M1.size2();
int sz2 = M2.size2();
std::vector<double> temp_v;
for(i=0; i < sz1; i++)
{
// go through all the M2's to see if there is a match
bool found = false;
for(j=0; j < sz2; j++)
{
if(M1(0,i) == M2(0,j))
{
found = true;
break;
}
}
// if there was no match save the M1
if(!found)
{
temp_v.push_back(M1(0,i));
}
}
// create a matrix to return
MatrixD M3(1,temp_v.size());
std::sort(temp_v.begin(), temp_v.end());
for(i = 0; i < temp_v.size() ; i++)
{
M3(0,i) = temp_v[i];
}
return M3;
}
double scoreFeature(State& state, double f)
{
// score feature
// DGREEN : adjust for c++ indexing
int K = (int)state.f(0,f) - 1;
MatrixD M = project(state.o, range(K, K+1) , range(0, state.o.size2()));
MatrixD c = unique(M);
double logP = 0;
int j,k,l;
int len = c.size2();
for(j=0; j < len ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(K,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M2(sz,1);
for(l=0;l < sz; l++)
{
M2(l,0) = state.data(indexes[l], f);
}
logP = logP + NG(M2, state.NG_mu(0,f), state.NG_k(0,f),
state.NG_a(0,f), state.NG_b(0,f));
}
return logP;
}
//////////////////////////////////////////////////////////
// the probability of a partition under the CRP
//
// cats: (integer array) storing assignment of categories where each element
// stores the category index
// gamma: (real) CRP parameter
double crp(const MatrixD& cats, double gama)
{
MatrixD u = unique(cats); // unique categories
int len = length(u);
MatrixD num = zeros(1,len);
int i;
for(i=0; i < len ; i++)
{
int index = (int)u(0,i);
int num_sz = length(num);
// check if we need to resize num
if(index > num_sz)
{
// copy current num vals into new larger array
MatrixD M = zeros(1, index);
project(M, range(0,1), range(0, num_sz)) = num;
num = M;
}
else if(index < 1)
{
cout<<" crp : index is zero, skipping " << index;
}
else
{
// number of elements in each category
// DGREEN : adjust index for c++ indexing
num(0, index - 1) = CountInstances(cats, index); // sum(cats==index);
}
}
double logP = prob_of_partition_via_counts(num, gama);
return logP;
}
//////////////////////////////////////////////////////////////////
// probability of the partition in ns under a CRP with concentration parameter
// gama (note that gama here is NOT the gamma function but just a number)
double prob_of_partition_via_counts(MatrixD& ns, double gama)
{
// ns=ns(ns~=0); // only consider classes that are not empty
ns = StripZeros(ns);
double k = (double)length(ns); // number of classes
double n = sum(ns); //number of samples
double l = sum(gammaln(ns)) + k*log(gama) + lgamma(gama) - lgamma(n+gama);
return l;
}
MatrixD gammaln(const MatrixD M)
{
MatrixD M2(M.size1(), M.size2());
int i,j;
int index = 0;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
M2(i,j) = lgamma(M(i,j));
}
}
return M2;
}
/////////////////////////////////////////////
// return a new matrix that has all zero
// elements removed
MatrixD StripZeros(const MatrixD& M)
{
int count = CountInstances(M, 0);
MatrixD M2(1, M.size2() - count);
int i,j;
int index = 0;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
int val = (int)M(i,j);
if(val != 0)
{
M2(0,index++) = val;
}
}
}
return M2;
}
///////////////////////////////////////////////
// count the number of times val appears in M
int CountInstances(const MatrixD& M, int val)
{
int count = 0;
int i,j;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
int temp = (int)M(i,j);
if(temp == val)
count++;
}
}
return count;
}
////////////////////////////////////////////
// return unique elements of M in sorted
// order as a row matrix
MatrixD unique(const MatrixD& M)
{
int i,j;
std::map<int, int> vals;
for(i=0; i < M.size1(); i++)
{
for(j=0; j < M.size2(); j++)
{
int v = (int)M(i,j);
vals[v] = v;
}
}
std::map<int,int>::iterator it = vals.begin();
std::vector<int> temp;
for(; it != vals.end(); it++)
{
temp.push_back(it->second);
}
std::sort(temp.begin(), temp.end());
MatrixD result(1, temp.size());
for(i=0; i < result.size2() ; i++)
{
result(0,i) = temp[i];
}
return result;
}
////////////////////////////////////////////////////////////////////
// this samples category partions given # objects from crp prior
//
// n: (integer) total number of objects to be partitioned
// gama: (real) scalar parameter for CRP
//
// partition: (integeger 1xn array) assignment of category for each object
MatrixD sample_partition(int n, double gamma)
{
using namespace boost::assign;
MatrixD partition = ones(1, n);
// classes store the number of objects assigned to each category; it always has
// the total number of categories plus 1. The last element is 0, which indicates
// the new class with no objects.
std::vector<int> classes;
classes += 1,0;
int i,j;
for(i=2 ; i <= n; i++)
{
std::vector<double> classprobs;
for(j=0 ; j < classes.size() ; j++)
{
// Calculate probabilities for each existing category and for the new
// category to assign to the i-th object.
double denom = (double)i - 1.0 + gamma;
if( classes[j] > 0.5)
{
// cout << "EXist" << endl;
// probability for the existing category j
double val = (double)classes[j];
classprobs.push_back(val/denom);
}
else
{
//cout << "New" << endl;
// probability for the new category (classes(j)=0)
classprobs.push_back(gamma / denom);
}
}
// cumulative probability function
MatrixD cumclassprobs = cumsum2(classprobs);
//Take a random draw to determine which category the i-th object should belong.
std::vector<int> V;
int k = 0;
double rand = GP.Rand.next();
for(k=0; k < cumclassprobs.size2(); k++)
{
double d = cumclassprobs(0,k);
if(rand < d)
{
V.push_back(k);
}
}
int c = *std::min_element(V.begin(), V.end());
// DGREEN : add one for c++ indexing
partition(0,i-1) = c + 1;
classes[c] = classes[c] + 1; // total no. of objects in that category
// if we add new category, need to replace placeholder
if(c == classes.size() - 1)
{
classes.push_back(0);
}
}
return partition;
}
///////////////////////////////
// return i from M(0, :)
// where M(0, i) > rand
// ALERT! : assumes M is 1 x n
// return first element > rand
int GetFirstIndex(const MatrixD& M, double val)
{
double rand = GP.Rand.next();
int n = M.size2();
int i;
int result = 0;
for(i=0;i < n; i++)
{
if(M(0,i) > rand)
{
result = i;
break;
}
}
return result;
}
/////////////////////////////////////////////////
// VERIFIED
void SetaRange(State& state)
{
double temp_d = (double)state.O/2.0;
double binsD = (double)GP.bins;
MatrixD tmp = linspace(0.5, temp_d / (temp_d + 1.0) , (binsD+1.0) / 2.0);
matrix_range< MatrixD> mr3(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
MatrixD y = -tmp + ones(1, tmp.size2());
y = element_div(tmp, y);
state.aRange = Concat(mr3, y);
}
////////////////////////////////////////////////////
// VERIFIED
void SetCrpParameterRanges(State& state)
{
double F = (double)state.F;
double binsD = (double)GP.bins;
MatrixD tmp = linspace(0.5, F / (F + 1.0), (binsD+1.0) / 2.0);
matrix_range< MatrixD> mr1(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
MatrixD y = ones(1, tmp.size2()) - tmp;
y = element_div(tmp, y);
state.crpKRange = Concat(mr1, y);
double O = (double)state.O;
tmp = linspace(0.5, O / (O + 1.0), (binsD+1.0) / 2.0);
matrix_range< MatrixD> mr2(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
y = -tmp + ones(1, tmp.size2());
y = element_div(tmp, y);
state.crpCRange = Concat(mr2, y);
}
/////////////////////////////////////////////
// VERIFIED
void SetMuBetaRanges(State& state)
{
int f = 0;
state.muRange.resize(state.F, 30);
state.bRange.resize(state.F, GP.bins);
for(f=0;f < state.F; f++)
{
// mu
MatrixD M1 = project(state.data, range(0, state.data.size1()), range(f,f+1));
double t1 = *std::min_element(M1.begin1(), M1.end1());
double t2 = *std::max_element(M1.begin1(), M1.end1());
MatrixD M2 = linspace(t1,t2,30);
project(state.muRange, range(f, f+1), range(0, M2.size2())) = M2;
// set b max based on empirical SSD
M2 = M1 - (ones(M1.size1(),M1.size2()) * mean(M1));
M2 = element_prod(M2,M2);
double ssd = sum(M2);
M1 = linspace(0.5, ssd / (ssd + 1), (GP.bins + 1) / 2);
M2 = ones(1, M1.size2()) - M1;
M2 = element_div(M1, M2);
matrix_range< MatrixD> mr1(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
M2 = Concat(mr1, M2);
project(state.bRange, range(f, f+1), range(0, M2.size2())) = M2;
}
}
double mean(const MatrixD& M)
{
int m = M.size1();
int n = M.size2();
int i,j;
double mean = sum(M);
mean = mean / ((double)m*n);
return mean;
}
void SaveMatrix(const MatrixD& M, std::string filename)
{
ofstream out(filename.c_str());
if(!out)
{
cout << "Cannot open file.\n";
return;
}
int m = M.size1();
int n = M.size2();
cout.setf(std::ios::scientific, std::ios::floatfield);
cout.precision(10);
int i,j;
for(i=0;i < m; i++)
{
for(j=0;j<n;j++)
{
out<<M(i,j);
if(j<(n-1))
out << ",";
}
out<<endl;
}
out.close();
}
// concat the two matrices , returns empty matrix
// if there is no common dimension
MatrixD Concat(const MatrixD& M1, const MatrixD& M2)
{
MatrixD R;
int m1 = M1.size1();
int n1 = M1.size2();
int m2 = M2.size1();
int n2 = M2.size2();
int i,j;
if(m1 == m2)
{
R.resize(m1, n1 + n2);
for(i=0;i<m1;i++)
{
for(j=0;j<(n1+n2);j++)
{
if(j<n1)
{
R(i,j) = M1(i,j);
}
else
{
R(i,j) = M2(i,j-n1);
}
}
}
}
else if(n1 == n2)
{
R.resize(m1 + m2, n1);
for(i=0;i<n1;i++)
{
for(j=0;j<(m1+m2);j++)
{
if(j<m1)
{
R(j,i) = M1(j,i);
}
else
{
R(j,i) = M2(j-m1,i);
}
}
}
}
return R;
}
// assume 2D matrix, add val to every element
void Add(MatrixD& M , double val)
{
int m = M.size1();
int n = M.size2();
int i,j;
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
M(i,j) += val;
}
}
}
void Print(const MatrixD& M, const std::string msg)
{
cout << msg << " = " << endl << M << endl << endl;
}
void PrintV(const std::vector<double>& V, const std::string msg)
{
int i;
cout << msg << " = " << endl;
for(i=0;i < V.size(); i++)
{
cout << V[i] ;
if(i < (V.size() - 1))
{
cout << ",";
}
}
cout << endl;
}
// compute cummulative sum , expects
// a 1 x n or n x 1 matrix and sums
// along the n dimension. add support
// for m x n matrices later if needed.
MatrixD cumsum(const MatrixD& M, int dim )
{
MatrixD result(M.size1(), M.size2());
if(M.size1() == 1)
{
int i = 0;
result(0,0) += M(0,0);
for(i = 1; i < M.size2(); i ++)
{
result(0,i) = result(0, i-1) + M(0,i);
}
}
else if(M.size2() == 1)
{
int i = 0;
result(0,0) = M(0,0);
for(i = 1; i < M.size2(); i ++)
{
result(i,0) = result(i-1,0) + M(i,0);
}
}
return result;
}
MatrixD cumsum2(const std::vector<double>& V)
{
MatrixD result(1, V.size());
int i = 0;
result(0,0) += V[0];
for(i = 1; i < V.size(); i ++)
{
result(0,i) = result(0, i-1) + V[i];
}
return result;
}
// returns the sum of all the elements
double sum(const MatrixD& M)
{
double result = 0;
int m = M.size1();
int n = M.size2();
int i,j;
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
result += M(i,j);
}
}
return result;
}
////////////////////////////////////////////
// init a matrix monotonically increasing
// steps of 1 from [start , end ] (inclusive)
MatrixD init_matrix_mti(int start, int end)
{
int len = end - start + 1;
MatrixD M(1, len);
int i;
for(i=0; i < len ; i++)
{
M(0,i) = start + i;
}
return M;
}
// returns matrix initialized with ones
MatrixD ones(int nrows, int ncols)
{
return init_matrix(nrows, ncols, 1.0);
}
// returns matrix initialized with ones
MatrixD zeros(int nrows, int ncols)
{
return init_matrix(nrows, ncols, 0);
}
MatrixD init_matrix(int nrows, int ncols, double val)
{
MatrixD M(nrows, ncols);
int i,j;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
M(i,j) = val;
}
}
return M;
}
int length(const MatrixD& M)
{
int l;
if(M.size1() > M.size2())
l = M.size1();
else
l = M.size2();
return l;
}
///////////////////////////////////////////////////////
// VERIFIED
MatrixD linspace(double x1, double x2, int num_elements)
{
MatrixD M(1,num_elements);
double x3 = (double)(num_elements - 1);
double step = (x2 - x1) / x3;
M(0,0) = x1;
int i = 0;
for(i = 1; i < M.size2(); i++)
{
M(0,i) = x1 + ((double)i*step);
}
return M;
}
//////////////////////////////////////////////////////////////
// load a cfg file and set GlobalParams based on contents
void LoadCfg(std::string file, GlobalParameters& GP)
{
ifstream in(file.c_str());
if (!in.is_open())
return;
typedef tokenizer< char_separator<char> > Tokenizer;
char_separator<char> sep(",");
}
/////////////////////////////////////////////////////////////////////
// expect a csv file of data
void LoadData(std::string file, boost::numeric::ublas::matrix<double>& M)
{
ifstream in(file.c_str());
if (!in.is_open())
return;
typedef tokenizer< char_separator<char> > Tokenizer;
char_separator<char> sep(",");
string line;
int nrows = 0;
int ncols = 0;
std::vector<string> vec;
// get the size first
while (std::getline(in,line))
{
Tokenizer tok(line, sep);
vec.assign(tok.begin(), tok.end());
ncols = vec.end() - vec.begin();
nrows++;
}
cout << "num rows = "<< nrows << " num cols = " << ncols << endl;
// create a matrix to hold data
matrix<double> Data(nrows, ncols);
// make second pass
in.clear();
in.seekg(0);
int r = 0;
while (std::getline(in,line))
{
Tokenizer tok(line, sep);
vec.assign(tok.begin(), tok.end());
int i = 0;
for(i=0; i < vec.size() ; i++)
{
Data(r, i) = ::strtod(vec[i].c_str(), 0);
}
r++;
}
M = Data;
}
double get_element(MatrixD M, int i, int j)
{
return M(i,j);
}
parse input parameters via boost::program_options
enable setting of seed in RandomNumberGen
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream> // cout, endl
#include <iomanip>
#include <fstream> // fstream
#include <vector>
#include <string>
#include <algorithm> // copy
#include <iterator> // ostream_operator
#include <ctime>
#include <map>
#include <boost/math/constants/constants.hpp>
#include <boost/assign/std/vector.hpp>
#include <boost/tokenizer.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/normal_distribution.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/program_options.hpp>
#include "DateTime.h"
using namespace std;
using namespace boost;
using namespace boost::numeric::ublas;
typedef boost::numeric::ublas::vector<double> VectorD;
typedef boost::numeric::ublas::matrix<double> MatrixD;
class State;
void MainLoop(State& state);
void SaveResults(const std::vector<State>& samples);
void SaveMatrix(const MatrixD& M, std::string filename);
void SetaRange(State& state);
void SetCrpParameterRanges(State& state);
void SetMuBetaRanges(State& state);
MatrixD Concat(const MatrixD& M1, const MatrixD& M2);
void Add(MatrixD& M , double val);
void Print(const MatrixD& M, const std::string msg);
void PrintV(const std::vector<double>& V, const std::string msg);
void LoadData(std::string file, MatrixD&);
MatrixD linspace(double x1, double x2, int num_elements);
MatrixD ones(int nrows, int ncols);
MatrixD zeros(int nrows, int ncols);
MatrixD init_matrix(int nrows, int ncols, double vals);
double sum(const MatrixD& M);
MatrixD cumsum(const MatrixD& M, int dim = 2);
MatrixD cumsum2(const std::vector<double>& V);
double mean(const MatrixD& M);
int GetFirstIndex(const MatrixD& M1, double r);
int length(const MatrixD& M);
MatrixD unique(const MatrixD& M);
int CountInstances(const MatrixD& M, int val);
MatrixD StripZeros(const MatrixD& M);
MatrixD gammaln(const MatrixD M);
MatrixD Exp(const MatrixD& M);
MatrixD init_matrix_mti(int start, int end);
MatrixD setdiff(const MatrixD& M1 , const MatrixD& M2);
MatrixD get_row(const MatrixD M, int i);
MatrixD find_indexes(const MatrixD M, int val);
////////////////////////////////////////////////
// utility function for use with running in gdb
double get_element(MatrixD M, int i, int j);
///////////////////////////////////////////////////////
// functions from m file
MatrixD sample_partition(int n, double gamma);
State drawSample(State& state, int lag);
State sampleHyperParams(State& state);
State sampleKinds(State& state);
State sampleCategories(State& state);
State sampleCategoriesK(State& state, int K, int O);
double crp(const MatrixD& cats, double gamma);
double prob_of_partition_via_counts(MatrixD& ns, double gama);
int chooseState(const MatrixD& logP);
double logsumexp(const MatrixD& a , int dim);
void jumpParam(State& state, int f, double& ng_mu, double& NG_a,
double& NG_b, double& NG_k);
double NG(const MatrixD& data, double mu0, double k0, double a0, double b0);
double sampleMu(const State& state, int f, const MatrixD c, int thisK);
double sampleA(const State& state, int f, const MatrixD c, int thisK);
double sampleB(const State& state, int f, const MatrixD c, int thisK);
double sampleK(const State& state, int f, const MatrixD c, int thisK);
double scoreFeature(State& state, double f);
double scoreObject(State& state, int K , int O);
double NG_cat(const MatrixD& data, double newData, double mu0, double k0, double a0, double b0);
class RandomNumberGen
{
public:
RandomNumberGen() : _engine(0), _dist(_engine)
//RandomNumberGen() : _engine(std::time_t(0)), _dist(_engine)
{
}
//////////////////////////////////
// return a random real between
// 0 and 1 with uniform dist
double next()
{
return _dist();
}
//////////////////////////////
// return a random int bewteen
// zero and max - 1 with uniform
// dist if called with same max
int nexti(int max)
{
double D = (double)max;
return (int)std::floor((next() * D));
}
void set_seed(std::time_t seed) {
_engine.seed(seed);
}
protected:
// Mersenne Twister
boost::mt19937 _engine;
// uniform Distribution
boost::uniform_01<boost::mt19937> _dist;
};
class State
{
public:
State() {}
~State() {}
int F;
int O;
MatrixD f;
MatrixD o;
MatrixD paramPrior;
MatrixD cumParamPrior;
MatrixD paramRange;
MatrixD crpKRange;
MatrixD crpCRange;
MatrixD kRange;
MatrixD aRange;
MatrixD muRange;
MatrixD bRange;
double crpPriorK;
double crpPriorC;
MatrixD NG_a;
MatrixD NG_k;
MatrixD NG_b;
MatrixD NG_mu;
MatrixD data;
};
class GlobalParameters
{
public:
GlobalParameters() : PI(boost::math::constants::pi<double>())
{
}
const double PI;
// set some initial vars
int nChains;
int nSamples;
int burnIn;
int lag;
int bins;
string dataFile;
RandomNumberGen Rand;
};
GlobalParameters GP;
int main(int argc, char** argv)
{
string default_dataFile = "SynData2";
std::time_t default_seed = 0;
string dataFile;
std::time_t seed;
//parse some arguments
namespace po = boost::program_options;
po::options_description desc("Options");
desc.add_options()
("help,h", "produce help message")
("seed", po::value<std::time_t>(&seed)->default_value(default_seed), "set inference seed")
("dataFile", po::value<string>(&dataFile)->default_value(default_dataFile), "set data to run inference on")
;
po::variables_map vm;
try {
po::store(po::parse_command_line( argc, argv, desc ), vm);
po::notify( vm );
if ( vm.count("help") ) {
std::cout << desc << "\n";
exit(0);
}
} catch ( const boost::program_options::error& e ) {
std::cerr << e.what() << std::endl;
}
using namespace boost::assign;
// set some initial vars
GP.nChains = 10;
GP.nSamples = 100;
GP.burnIn = 10;
GP.lag = 10;
GP.bins = 31;
//
GP.dataFile = dataFile;
GP.Rand.set_seed(seed);
cout << "dataFile = " << dataFile << endl;
cout << "seed = " << seed << endl;
State state;
// load data file
LoadData(GP.dataFile + ".csv", state.data);
// num cols
state.F = state.data.size2();
// num rows
state.O = state.data.size1();
// parameters
MatrixD x = linspace(0.03, 0.97, GP.bins);
state.paramPrior = ones(1, x.size2());
state.paramPrior = state.paramPrior / sum(state.paramPrior);
state.cumParamPrior = cumsum(state.paramPrior);
MatrixD y = -x + ones(1, x.size2());
state.paramRange = element_div(x, y);
// set CRP parameter ranges
SetCrpParameterRanges(state);
// set k parameter range
state.kRange = state.crpCRange;
// set 'a' range to n/2
SetaRange(state);
// set mu and beta ranges
SetMuBetaRanges(state);
MainLoop(state);
return 0;
}
void MainLoop(State& state)
{
std::vector<State> samples;
int nc = 1;
for(; nc <= GP.nChains; nc++)
{
cout<< "nc = " << nc << endl;
// initialize parameters randomly
int index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.crpPriorK = state.crpKRange(0,index);
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.crpPriorC = state.crpCRange(0,index);
int i;
state.NG_a.resize(1,state.F);
state.NG_k.resize(1,state.F);
state.NG_b.resize(1,state.F);
state.NG_mu.resize(1,state.F);
for(i = 0; i < state.F; i++)
{
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.NG_a(0,i) = state.aRange(0, index);
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.NG_k(0,i) = state.kRange(0, index);
index = GetFirstIndex(state.cumParamPrior, GP.Rand.next());
state.NG_b(0,i) = state.bRange(i, index);
index = GP.Rand.nexti(state.muRange.size2());
state.NG_mu(0,i) = state.muRange(i, index);
}
// initialize state
// state.f stores a partition of features; each element is the
// corresponding kind the feature is assigned to. It is an
// integer array of size 1 x state.F
state.f = sample_partition(state.F, state.crpPriorK);
//state.o stores a partition of objects for each category of
// features. It is an integer matrix of size kinds x state.O where
// kinds = max(staet.f).
int max = (int)*std::max_element(state.f.begin2(), state.f.end2());
state.o.resize(max, state.O);
for(i = 0; i < max; i++)
{
MatrixD Opart = sample_partition(state.O, state.crpPriorC);
project(state.o, range(i, i+1), range(0, Opart.size2())) = Opart;
}
// runModel
Timer T(true);
// burn-in
samples.push_back(drawSample(state, GP.burnIn));
// samples{length(samples)+1} = drawSample(state, burnIn);
cout <<" t1 = " << T.GetElapsed() << endl;
// storing MCMC samples
int ns;
for(ns=2; ns <= GP.nSamples; ns++)
{
// only store every 'lag' samples
cout << "ns = " << ns << endl;
samples.push_back(drawSample(samples[samples.size() - 1], GP.lag));
cout << "t2 = " << T.GetElapsed() << endl;
}
}
SaveResults(samples);
}
void SaveResults(const std::vector<State>& samples)
{
string filename = "crossCatNG_" + GP.dataFile + " (" + DateTime::GetDateTimeStr() + ")";
ofstream out(filename.c_str());
if(!out)
{
cout << "Cannot open file.\n";
return;
}
out << "nChains = " << GP.nChains << endl;
out << "nSamples = " << GP.nSamples << endl;
out << "burnIn = " << GP.burnIn << endl;
out << "lag = " << GP.lag << endl;
out << endl;
int i;
for(i = 0; i < samples.size() ;i++)
{
State state = samples[i];
out << "State"<<i<<endl;
out << "F = " << state.F << endl;
out << "O = " << state.O << endl;
out << "f = " << state.f << endl;
out << "o = " << state.o << endl;
out << "paramPrior = " << state.paramPrior << endl;
out << "cumParamPrior = " << state.cumParamPrior << endl;
out << "paramRange = " << state.paramRange << endl;
out << "crpKRange = " << state.crpKRange << endl;
out << "crpCRange = " << state.crpCRange << endl;
out << "kRange = " << state.kRange << endl;
out << "aRange = " << state.aRange << endl;
out << "muRange = " << state.muRange << endl;
out << "bRange = " << state.bRange << endl;
out << "crpPriorK = " << state.crpPriorK << endl;
out << "crpPriorC = " << state.crpPriorC << endl;
out << "NG_a = " << state.NG_a << endl;
out << "NG_k = " << state.NG_k << endl;
out << "NG_b = " << state.NG_b << endl;
out << "NG_mu = " << state.NG_mu << endl;
out << endl << endl;
}
out.close();
}
State drawSample(State& state, int lag)
{
int i;
for(i = 0; i < lag ; i++)
{
cout << i << endl;
//scoreState(state)
State oldstate = state;
// sample hyper parameters
//cout << "SampleHyperParams" << endl;
state = sampleHyperParams(state);
// sample kinds
//cout << "sampleKinds"<<endl;
if (state.F > 1)
{
//cout << "sampleKinds"<<endl;
state = sampleKinds(state);
}
//sample categories
//cout<<"sampleCategories"<<endl;
state = sampleCategories(state);
}
return state;
}
State sampleHyperParams(State& state)
{
// crpPrior kinds
int len = length(state.crpKRange);
MatrixD logP = zeros(1,len);
int i;
for(i = 0 ; i < len; i++)
{
state.crpPriorK = state.crpKRange(0,i); // assuming uniform prior
logP(0,i) = crp(state.f, state.crpPriorK); // only need to look at kinds
}
// choose state
int index = chooseState(logP); // normalize to probability distribution then take a sample
state.crpPriorK = state.crpKRange(0,index); // 'this' denotes the particular sample drawn
// crpPrior categories
logP = zeros(1,length(state.crpCRange));
int l = length(state.crpCRange);
for(i = 0; i < l; i++)
{
state.crpPriorC = state.crpCRange(0,i);
MatrixD u = unique(state.f);
//Print(state.f, "state.f");
//Print(u, "u");
int j;
for (j=0; j < u.size2(); j++)
{
// DGREEN : subtract 1 for c++ indexing
int k = u(0,j) - 1;
if(k < 0)
{
Print(state.f, "state.f");
Print(u, "u");
exit(0);
}
MatrixD M = project(state.o, range(k, k+1), range(0, state.o.size2()));
logP(0,i) = logP(0,i) + crp(M, state.crpPriorC); // only need to look at categories
}
}
// choose state
index = chooseState(logP);
state.crpPriorC = state.crpCRange(0,index);
// sample feature params
int f;
double NG_mu, NG_a, NG_b, NG_k;
for(f = 0; f < state.F; f++)
{
jumpParam(state, f, NG_mu, NG_a, NG_b, NG_k);
state.NG_a(0,f) = NG_a;
state.NG_b(0,f) = NG_b;
state.NG_k(0,f) = NG_k;
state.NG_mu(0,f) = NG_mu;
}
return state;
}
void jumpParam(State& state, int f, double& NG_mu, double& NG_a,
double& NG_b, double& NG_k)
{
// DGREEN : adjust for c++ indexing
double thisK = state.f(0,f) - 1; // the feature category (view) associated with f
MatrixD M;
M = project(state.o, range(thisK, thisK+1) , range(0, state.o.size2()));
MatrixD c = unique(M); // object category assignment for thisK (view)
NG_mu = sampleMu(state, f, c, thisK);
NG_a = sampleA(state, f, c, thisK);
NG_b = sampleB(state, f, c, thisK);
NG_k = sampleK(state, f, c, thisK);
}
double sampleMu(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.muRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.muRange(f,i), state.NG_k(0,f),
state.NG_a(0,f), state.NG_b(0,f));
}
}
// choose state
int s = chooseState(logP);
double NG_mu = state.muRange(f,s);
return NG_mu;
}
double sampleK(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.kRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.NG_mu(0,f), state.kRange(0,i),
state.NG_a(0,f), state.NG_b(0,f));
logP(0,i) = logP(0, i) + log(state.paramPrior(0,i));
}
}
// choose state
int s = chooseState(logP);
double NG_k = state.kRange(0,s) + 1.0;
return NG_k;
}
double sampleA(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.aRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.NG_mu(0,f), state.NG_k(0,f),
state.aRange(0,i), state.NG_b(0,f));
logP(0,i) = logP(0, i) + log(state.paramPrior(0,i));
}
}
// choose state
int s = chooseState(logP);
double NG_a = state.aRange(0,s);
return NG_a;
}
double sampleB(const State& state, int f, const MatrixD c, int thisK)
{
int len1 = state.bRange.size2();
MatrixD logP = zeros(1, len1);
int i,j,k,l;
int len2 = c.size2();
for(i=0; i < len1 ; i++)
{
for(j=0; j < len2 ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(thisK,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M(sz,1);
for(l=0;l < sz; l++)
{
M(l,0) = state.data(indexes[l], f);
}
logP(0,i) = logP(0,i) + NG(M, state.NG_mu(0,f), state.NG_k(0,f),
state.NG_a(0,f), state.bRange(f,i));
logP(0,i) = logP(0, i) + log(state.paramPrior(0,i)) ;
}
}
// choose state
int s = chooseState(logP);
double NG_b = state.bRange(f,s);
return NG_b;
}
// the probability of data, given the priors under the normal-normal-gamma
// model
// this is based on kevin murphy's cheat sheet (NG.pdf)
// data are assumed to be a vector
// mu0, k0, a0, b0 are hyperparameters
double NG(const MatrixD& data, double mu0, double k0, double a0, double b0)
{
double len = (double)length(data);
double meanData = sum(data) / len;
// muN = (k0.*mu0 + len.*meanData) ./ (k0+len);
double kN = k0 + len;
double aN = a0 + len / 2.0;
MatrixD diff1 = data;
Add(diff1, -meanData);
double diff2 = meanData - mu0;
MatrixD M = element_prod(diff1, diff1);
double bN = b0 + 0.5 * sum(M) + (k0*len*(diff2*diff2)) / (2.0*(k0+len));
double logProb = lgamma(aN) - lgamma(a0) +
log(b0) * a0 - log(bN) * aN +
log( (k0/kN) ) * 0.5 +
log( (2.0 * GP.PI) ) *(-len/2.0);
return logProb;
}
// Given unnormalized log probabilities, return a random sample
int chooseState(const MatrixD& logP)
{
MatrixD M = logP;
Add(M, -logsumexp(M,2));
MatrixD prob = Exp(M); // normalize to 1 given log-prob
MatrixD cumprob = cumsum(prob); // CDF
// find the first entry > rand
double rand = GP.Rand.next();
int i, result = 0;
for(i = 0; i < cumprob.size2(); i++)
{
if(cumprob(0,i) > rand)
{
result = i;
break;
}
}
return result;
}
/////////////////////////////////////////////////////////////////////
// Returns log(sum(exp(a),dim)) while avoiding numerical underflow.
// logsumexp(a, 2) will sum across columns instead of rows
// (ASSUMES row vector for now) users dim spec overridden
double logsumexp(const MatrixD& a , int dim)
{
MatrixD M = a;
dim = 2;
// subtract the largest in each column
double y = *std::max_element(M.begin2(), M.end2());
Add(M, -y);
double res = y + log(sum(Exp(M)));
return res;
}
//////////////////////////////////
// return matrix that applies
// exp operation on each element
MatrixD Exp(const MatrixD& M)
{
int i,j;
int m = M.size1();
int n = M.size2();
MatrixD result(m,n);
for(i=0;i < m; i++)
{
for(j=0; j < n; j++)
{
result(i,j) = ::exp(M(i,j));
}
}
return result;
}
////////////////////////////////////////////////////////////////////
// this includes gibbs moves on features, and M-H move to propose new
// kinds
State sampleKinds(State& state)
{
int f;
for(f=0 ; f < state.F ; f++)
{
MatrixD k = unique(state.f);
// first gibbs (only makes sense if there is more than one feature
// in this kind, and there is more than one kind)
if((CountInstances(state.f,state.f(0,f)) > 1) && (length(k) > 1))
{
std::vector<double> logP;
int j,K;
int len_k = k.size2();
for(j=0 ; j < len_k ; j++)
{
K = k(0,j);
if(K == 0)
{
cout<< "ERROR : K == 0" <<endl;
}
state.f(0,f) = K;
// crp
int sumF = CountInstances(state.f, K);
if(sumF > 1)
{
double temp = (double)sumF - 1.0;
temp = temp / (state.F - 1 + state.crpPriorK);
logP.push_back(log(temp));
}
else
{
logP.push_back(log(state.crpPriorK / (state.F - 1 + state.crpPriorK)));
}
logP[logP.size() - 1] += scoreFeature(state, f);
}
// create a matrix from logP
MatrixD logP_M(1, logP.size());
for(j=0; j < logP.size() ; j++)
{
logP_M(0,j) = logP[j];
}
int s = chooseState(logP_M);
int temp = k(0,s);
if(temp == 0)
{
cout << "ERROR temp = 0"<<endl;
}
state.f(0,f) = k(0,s);
}
// then MH choose new v old
double cut = 0.5; // percent new
State oldState = state;
bool newOld = (GP.Rand.next() > cut);
if( (length(k) == 1) && newOld)
{
continue;
}
double a;
if(!newOld) // new
{
// cout<< "new" << endl;
double logP_1, logP_2;
// sample partition
MatrixD M1 = init_matrix_mti(1, state.F + 1);
MatrixD M2 = setdiff(M1, k);
// newK gets first element
int newK = M2(0,0);
if(newK == 0)
{
cout<< "ERROR : newK = 0" << endl;
}
state.f(0,f) = newK;
// add new row to state.o if you have to
if(newK > state.o.size1())
{
MatrixD temp(newK, state.o.size2());
project(temp, range(0, newK - 1), range(0,state.o.size2())) = state.o;
state.o = temp;
}
project(state.o, range(newK-1, newK), range(0,state.o.size2())) = sample_partition(state.O, state.crpPriorC);
// score new and score old
MatrixD M3 = project(state.o, range(newK-1, newK) , range(0, state.o.size2()));
logP_1 = scoreFeature(state, f) + // score feature
log( state.crpPriorK / (double)(state.F - 1 + state.crpPriorK)) + // new kind
crp(M3, state.crpPriorC); // new categories
double d1 = (double)CountInstances(oldState.f, oldState.f(0,f)) - 1.0;
logP_2 = scoreFeature(oldState, f) + // score feature
log( d1 / (double)(oldState.F - 1 + oldState.crpPriorK)); // new kind
// M-H (t+1 -> t / t -> t+1)
double jump_1, jump_2;
if(CountInstances(oldState.f, oldState.f(0,f)) == 1) // deal with single feature kinds
{
// t + 1 -> t prob of new , prob of choosing cat t
MatrixD M1 = project(oldState.o, range(oldState.f(0,f) - 1, oldState.f(0,f)) ,
range(0, oldState.o.size2()));
jump_1 = log(cut) + crp(M1, state.crpPriorC);
// t -> t+1: prob of new, prob of choosing cat t+1
M1 = project(state.o, range(state.f(0,f) - 1, state.f(0,f)) ,
range(0, state.o.size2()));
jump_2 = log(cut) - crp(M1, state.crpPriorC);
}
else
{
// t+1 -> t: prob of old, prob of choosing kind @ t+1
jump_1 = log((1.0-cut)*(1.0/(double)length(unique(state.f))));
// t -> t+1: prob of new, prob of choosing cat t+1
MatrixD M1 = project(state.o, range(newK-1, newK) , range(0, state.o.size2()));
jump_2 = log(cut) + crp(M1,state.crpPriorC);
}
a = logP_1 - logP_2 + jump_1 - jump_2;
}
else // old
{
// from 1 to length(k)
int newK = 1 + GP.Rand.nexti(length(k));
if(newK == state.f(0,f))
{
continue;
}
double logP_1, logP_2;
double temp = (double)(CountInstances(oldState.f, oldState.f(0,f)) - 1);
logP_2 = scoreFeature(oldState,f) +
log( temp / (double)(oldState.F - 1 + oldState.crpPriorK) );
if(newK == 0)
{
cout<< "ERROR : newK == 0"<<endl;
}
state.f(0,f) = newK;
temp = (double)(CountInstances(state.f, state.f(0,f)));
logP_1 = scoreFeature(state,f) +
log( temp / (double)(state.F - 1 + state.crpPriorK) ) ;
double jump_1, jump_2;
// M-H transition (t+1 -> t / t -> t+1)
if(CountInstances(oldState.f, oldState.f(0,f)) == 1) // single feature kind
{
// t+1 -> t: prob of new, prob of choosing cat t
MatrixD M1 = project(oldState.o, range(oldState.f(0,f) - 1, oldState.f(0,f)),
range(0, oldState.o.size2()));
jump_1 = log(cut) + crp(M1, state.crpPriorC);
// t -> t+1: prob of old, prob of choosing kind @ t
jump_2 = log((1.0-cut) * (1.0/ (double)(length(unique(oldState.f)))));
a = logP_1 - logP_2 + jump_1 - jump_2;
}
else
{
// t+1 -> t: prob of old, prob of choosing kind (same # kinds)
jump_1 = 0;
// t -> t+1: prob of old, prob of choosing kind (same # kinds)
jump_2 = 0;
a = logP_1 - logP_2 + jump_1 - jump_2;
}
}
a = exp(a);
if( a > GP.Rand.next())
{
// state is adopted
}
else
{
// return to old state
state = oldState;
}
}
return state;
}
State sampleCategories(State& state)
{
MatrixD k = unique(state.f);
int i,O;
for(i=0;i < k.size2() ; i++)
{
// DGREEN : adjust K or c++ indexing
int K = k(0,i) - 1;
for(O=0; O < state.O; O++)
{
state = sampleCategoriesK(state, K, O);
}
}
return state;
}
// this executes gibbs sampling for a given kind
//
// K: (int) feature category (view) label
// O: (int) object index
State sampleCategoriesK(State& state, int K, int O)
{
MatrixD M1 = project(state.o, range(K, K+1), range(0, state.o.size2()));
MatrixD C = unique(M1);
// choose a label for new category
MatrixD M2 = init_matrix_mti(1, state.O);
MatrixD empty = setdiff(M2, C);
int max = *std::max_element(C.begin2(), C.end2());
if((empty.size2() == 0) && (max == state.O))
{
// do nothing
}
else
{
C = Concat(C, project(empty, range(0,1), range(0, 1)));
}
MatrixD logP(1, C.size2());
int i;
for(i = 0 ; i < C.size2(); i++)
{
int c = C(0,i);
state.o(K,O) = c;
// cout << "scoreObject" << endl;
logP(0,i) = scoreObject(state, K, O);
}
// choose state
int s = chooseState(logP);
state.o(K,O) = C(0,s);
return state;
}
/////////////////////////////////////////////////////////////////
// scores an object in a category. two parts: crp and likelihood
//
// K: (int) feature category (view) label
// O: (int) object index
double scoreObject(State& state, int K , int O)
{
// find all the indices in state.f where the element == K
// features corresponding to this view K
std::vector<int> theseF;
int i,j;
for(i = 0; i < state.f.size2(); i++)
{
if(state.f(0,i) == K+1) // DEBUG
{
theseF.push_back(i);
}
}
// crp
double logP;
MatrixD M1 = project(state.o, range(K, K+1), range(0, state.o.size2()));
int sumO = CountInstances(M1, state.o(K,O));
if(sumO > 1)
{
logP = log( ((double)sumO - 1.0) / ((double)state.O - 1 + state.crpPriorC));
}
else
{
logP = log( ( state.crpPriorC / ((double)state.O - 1.0 + state.crpPriorC)));
}
// score likelihood of data
M1 = get_row(state.o, K);
MatrixD theseData = find_indexes(M1, state.o(K,O));
theseData(0,O) = 0; // eliminate this object
for(i=0; i < theseF.size(); i++)
{
int f = theseF[i];
std::vector<double> V;
for(j=0;j < theseData.size2(); j++)
{
if((int)theseData(0,j) == 1)
{
V.push_back(state.data(j,f));
}
}
MatrixD M2(1, V.size());
for(j=0;j<V.size();j++)
{
M2(0,j) = V[j];
}
logP = logP + NG_cat(M2, state.data(O,f), state.NG_mu(0,f),
state.NG_k(0,f), state.NG_a(0,f), state.NG_b(0,f));
}
return logP;
}
/////////////////////////////////////////////////////////////////
// probability of a datum given priors and other data
//
// data: column data
// newData: real
// this is based on kevin murphy's cheat sheet (NG.pdf)
// data are assumed to be a vector
// mu0, k0, a0, b0 are hyperparameters
// NOTE: this version is for the gibbs sampler for categories
double NG_cat(const MatrixD& data, double newData, double mu0, double k0, double a0, double b0)
{
// this is updating based on old data
double len, meanData;
double logProb;
if(data.size2() == 0)
{
// do nothing
}
else
{
// NOTE: this could be cached
double len = (double)length(data);
double meanData = sum(data) / len;
mu0 = ((k0 * mu0) + (len * meanData)) / (k0 + len);
k0 = k0 + len;
a0 = a0 + len / 2.0;
MatrixD diff1 = data;
Add(diff1, -meanData);
double diff2 = meanData - mu0;
b0 = b0 + 0.5 * sum(element_prod(diff1,diff1)) +
(k0*len*(diff2*diff2)) / (2.0 * (k0 + len));
}
// this is always a scaler
len = 1.0; //(double)length(newData);
meanData = newData;
// now update with new data
// muN = (k0.*mu0 + len.*meanData) ./ (k0+len);
double kN = k0 + len;
double aN = a0 + len/2.0;
double newdiff1 = 0;
double newdiff2 = meanData - mu0;
double bN = b0 + 0.5 * (newdiff1 * newdiff1) + (k0 * len * (newdiff2 * newdiff2)) / (2.0 * (k0 + len));
logProb = lgamma(aN) - lgamma(a0) + log(b0) * a0 - log(bN) * aN +
log((k0/kN)) * 0.5 + log( (2.0 * GP.PI) ) * (-len/2.0);
return logProb;
}
////////////////////////////////////////////////////////
// return a binary array same size as M with 0 or 1
// in element (i,j) indicating M1(i,j) == val
MatrixD find_indexes(const MatrixD M, int val)
{
MatrixD M2 = zeros(M.size1(), M.size2());
int i,j;
for(i=0; i < M2.size1() ; i++)
{
for(j=0; j < M2.size2() ; j++)
{
int m = (int)M(i,j);
if(m == val)
{
M2(i,j) = 1;
}
}
}
return M2;
}
/////////////////////////////////////////////////////
// return a new 1 x n matrix that is the nth row of M
MatrixD get_row(const MatrixD M, int i)
{
return project(M, range(i, i+1) , range(0, M.size2()));
}
// assume column vectors , vals will be treated as
// integers find M1's not in M2 , return sorted
MatrixD setdiff(const MatrixD& M1, const MatrixD& M2)
{
int i,j;
int sz1 = M1.size2();
int sz2 = M2.size2();
std::vector<double> temp_v;
for(i=0; i < sz1; i++)
{
// go through all the M2's to see if there is a match
bool found = false;
for(j=0; j < sz2; j++)
{
if(M1(0,i) == M2(0,j))
{
found = true;
break;
}
}
// if there was no match save the M1
if(!found)
{
temp_v.push_back(M1(0,i));
}
}
// create a matrix to return
MatrixD M3(1,temp_v.size());
std::sort(temp_v.begin(), temp_v.end());
for(i = 0; i < temp_v.size() ; i++)
{
M3(0,i) = temp_v[i];
}
return M3;
}
double scoreFeature(State& state, double f)
{
// score feature
// DGREEN : adjust for c++ indexing
int K = (int)state.f(0,f) - 1;
MatrixD M = project(state.o, range(K, K+1) , range(0, state.o.size2()));
MatrixD c = unique(M);
double logP = 0;
int j,k,l;
int len = c.size2();
for(j=0; j < len ; j++)
{
// find indexes where state.o(thisK,:) == c(0,j)
std::vector<int> indexes;
for(k=0; k < state.o.size2(); k++)
{
if(state.o(K,k) == c(0,j))
indexes.push_back(k);
}
// save to M
int sz = indexes.size();
MatrixD M2(sz,1);
for(l=0;l < sz; l++)
{
M2(l,0) = state.data(indexes[l], f);
}
logP = logP + NG(M2, state.NG_mu(0,f), state.NG_k(0,f),
state.NG_a(0,f), state.NG_b(0,f));
}
return logP;
}
//////////////////////////////////////////////////////////
// the probability of a partition under the CRP
//
// cats: (integer array) storing assignment of categories where each element
// stores the category index
// gamma: (real) CRP parameter
double crp(const MatrixD& cats, double gama)
{
MatrixD u = unique(cats); // unique categories
int len = length(u);
MatrixD num = zeros(1,len);
int i;
for(i=0; i < len ; i++)
{
int index = (int)u(0,i);
int num_sz = length(num);
// check if we need to resize num
if(index > num_sz)
{
// copy current num vals into new larger array
MatrixD M = zeros(1, index);
project(M, range(0,1), range(0, num_sz)) = num;
num = M;
}
else if(index < 1)
{
cout<<" crp : index is zero, skipping " << index;
}
else
{
// number of elements in each category
// DGREEN : adjust index for c++ indexing
num(0, index - 1) = CountInstances(cats, index); // sum(cats==index);
}
}
double logP = prob_of_partition_via_counts(num, gama);
return logP;
}
//////////////////////////////////////////////////////////////////
// probability of the partition in ns under a CRP with concentration parameter
// gama (note that gama here is NOT the gamma function but just a number)
double prob_of_partition_via_counts(MatrixD& ns, double gama)
{
// ns=ns(ns~=0); // only consider classes that are not empty
ns = StripZeros(ns);
double k = (double)length(ns); // number of classes
double n = sum(ns); //number of samples
double l = sum(gammaln(ns)) + k*log(gama) + lgamma(gama) - lgamma(n+gama);
return l;
}
MatrixD gammaln(const MatrixD M)
{
MatrixD M2(M.size1(), M.size2());
int i,j;
int index = 0;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
M2(i,j) = lgamma(M(i,j));
}
}
return M2;
}
/////////////////////////////////////////////
// return a new matrix that has all zero
// elements removed
MatrixD StripZeros(const MatrixD& M)
{
int count = CountInstances(M, 0);
MatrixD M2(1, M.size2() - count);
int i,j;
int index = 0;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
int val = (int)M(i,j);
if(val != 0)
{
M2(0,index++) = val;
}
}
}
return M2;
}
///////////////////////////////////////////////
// count the number of times val appears in M
int CountInstances(const MatrixD& M, int val)
{
int count = 0;
int i,j;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
int temp = (int)M(i,j);
if(temp == val)
count++;
}
}
return count;
}
////////////////////////////////////////////
// return unique elements of M in sorted
// order as a row matrix
MatrixD unique(const MatrixD& M)
{
int i,j;
std::map<int, int> vals;
for(i=0; i < M.size1(); i++)
{
for(j=0; j < M.size2(); j++)
{
int v = (int)M(i,j);
vals[v] = v;
}
}
std::map<int,int>::iterator it = vals.begin();
std::vector<int> temp;
for(; it != vals.end(); it++)
{
temp.push_back(it->second);
}
std::sort(temp.begin(), temp.end());
MatrixD result(1, temp.size());
for(i=0; i < result.size2() ; i++)
{
result(0,i) = temp[i];
}
return result;
}
////////////////////////////////////////////////////////////////////
// this samples category partions given # objects from crp prior
//
// n: (integer) total number of objects to be partitioned
// gama: (real) scalar parameter for CRP
//
// partition: (integeger 1xn array) assignment of category for each object
MatrixD sample_partition(int n, double gamma)
{
using namespace boost::assign;
MatrixD partition = ones(1, n);
// classes store the number of objects assigned to each category; it always has
// the total number of categories plus 1. The last element is 0, which indicates
// the new class with no objects.
std::vector<int> classes;
classes += 1,0;
int i,j;
for(i=2 ; i <= n; i++)
{
std::vector<double> classprobs;
for(j=0 ; j < classes.size() ; j++)
{
// Calculate probabilities for each existing category and for the new
// category to assign to the i-th object.
double denom = (double)i - 1.0 + gamma;
if( classes[j] > 0.5)
{
// cout << "EXist" << endl;
// probability for the existing category j
double val = (double)classes[j];
classprobs.push_back(val/denom);
}
else
{
//cout << "New" << endl;
// probability for the new category (classes(j)=0)
classprobs.push_back(gamma / denom);
}
}
// cumulative probability function
MatrixD cumclassprobs = cumsum2(classprobs);
//Take a random draw to determine which category the i-th object should belong.
std::vector<int> V;
int k = 0;
double rand = GP.Rand.next();
for(k=0; k < cumclassprobs.size2(); k++)
{
double d = cumclassprobs(0,k);
if(rand < d)
{
V.push_back(k);
}
}
int c = *std::min_element(V.begin(), V.end());
// DGREEN : add one for c++ indexing
partition(0,i-1) = c + 1;
classes[c] = classes[c] + 1; // total no. of objects in that category
// if we add new category, need to replace placeholder
if(c == classes.size() - 1)
{
classes.push_back(0);
}
}
return partition;
}
///////////////////////////////
// return i from M(0, :)
// where M(0, i) > rand
// ALERT! : assumes M is 1 x n
// return first element > rand
int GetFirstIndex(const MatrixD& M, double val)
{
double rand = GP.Rand.next();
int n = M.size2();
int i;
int result = 0;
for(i=0;i < n; i++)
{
if(M(0,i) > rand)
{
result = i;
break;
}
}
return result;
}
/////////////////////////////////////////////////
// VERIFIED
void SetaRange(State& state)
{
double temp_d = (double)state.O/2.0;
double binsD = (double)GP.bins;
MatrixD tmp = linspace(0.5, temp_d / (temp_d + 1.0) , (binsD+1.0) / 2.0);
matrix_range< MatrixD> mr3(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
MatrixD y = -tmp + ones(1, tmp.size2());
y = element_div(tmp, y);
state.aRange = Concat(mr3, y);
}
////////////////////////////////////////////////////
// VERIFIED
void SetCrpParameterRanges(State& state)
{
double F = (double)state.F;
double binsD = (double)GP.bins;
MatrixD tmp = linspace(0.5, F / (F + 1.0), (binsD+1.0) / 2.0);
matrix_range< MatrixD> mr1(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
MatrixD y = ones(1, tmp.size2()) - tmp;
y = element_div(tmp, y);
state.crpKRange = Concat(mr1, y);
double O = (double)state.O;
tmp = linspace(0.5, O / (O + 1.0), (binsD+1.0) / 2.0);
matrix_range< MatrixD> mr2(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
y = -tmp + ones(1, tmp.size2());
y = element_div(tmp, y);
state.crpCRange = Concat(mr2, y);
}
/////////////////////////////////////////////
// VERIFIED
void SetMuBetaRanges(State& state)
{
int f = 0;
state.muRange.resize(state.F, 30);
state.bRange.resize(state.F, GP.bins);
for(f=0;f < state.F; f++)
{
// mu
MatrixD M1 = project(state.data, range(0, state.data.size1()), range(f,f+1));
double t1 = *std::min_element(M1.begin1(), M1.end1());
double t2 = *std::max_element(M1.begin1(), M1.end1());
MatrixD M2 = linspace(t1,t2,30);
project(state.muRange, range(f, f+1), range(0, M2.size2())) = M2;
// set b max based on empirical SSD
M2 = M1 - (ones(M1.size1(),M1.size2()) * mean(M1));
M2 = element_prod(M2,M2);
double ssd = sum(M2);
M1 = linspace(0.5, ssd / (ssd + 1), (GP.bins + 1) / 2);
M2 = ones(1, M1.size2()) - M1;
M2 = element_div(M1, M2);
matrix_range< MatrixD> mr1(state.paramRange, range(0, 1), range(0 , (GP.bins-1) / 2));
M2 = Concat(mr1, M2);
project(state.bRange, range(f, f+1), range(0, M2.size2())) = M2;
}
}
double mean(const MatrixD& M)
{
int m = M.size1();
int n = M.size2();
int i,j;
double mean = sum(M);
mean = mean / ((double)m*n);
return mean;
}
void SaveMatrix(const MatrixD& M, std::string filename)
{
ofstream out(filename.c_str());
if(!out)
{
cout << "Cannot open file.\n";
return;
}
int m = M.size1();
int n = M.size2();
cout.setf(std::ios::scientific, std::ios::floatfield);
cout.precision(10);
int i,j;
for(i=0;i < m; i++)
{
for(j=0;j<n;j++)
{
out<<M(i,j);
if(j<(n-1))
out << ",";
}
out<<endl;
}
out.close();
}
// concat the two matrices , returns empty matrix
// if there is no common dimension
MatrixD Concat(const MatrixD& M1, const MatrixD& M2)
{
MatrixD R;
int m1 = M1.size1();
int n1 = M1.size2();
int m2 = M2.size1();
int n2 = M2.size2();
int i,j;
if(m1 == m2)
{
R.resize(m1, n1 + n2);
for(i=0;i<m1;i++)
{
for(j=0;j<(n1+n2);j++)
{
if(j<n1)
{
R(i,j) = M1(i,j);
}
else
{
R(i,j) = M2(i,j-n1);
}
}
}
}
else if(n1 == n2)
{
R.resize(m1 + m2, n1);
for(i=0;i<n1;i++)
{
for(j=0;j<(m1+m2);j++)
{
if(j<m1)
{
R(j,i) = M1(j,i);
}
else
{
R(j,i) = M2(j-m1,i);
}
}
}
}
return R;
}
// assume 2D matrix, add val to every element
void Add(MatrixD& M , double val)
{
int m = M.size1();
int n = M.size2();
int i,j;
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
M(i,j) += val;
}
}
}
void Print(const MatrixD& M, const std::string msg)
{
cout << msg << " = " << endl << M << endl << endl;
}
void PrintV(const std::vector<double>& V, const std::string msg)
{
int i;
cout << msg << " = " << endl;
for(i=0;i < V.size(); i++)
{
cout << V[i] ;
if(i < (V.size() - 1))
{
cout << ",";
}
}
cout << endl;
}
// compute cummulative sum , expects
// a 1 x n or n x 1 matrix and sums
// along the n dimension. add support
// for m x n matrices later if needed.
MatrixD cumsum(const MatrixD& M, int dim )
{
MatrixD result(M.size1(), M.size2());
if(M.size1() == 1)
{
int i = 0;
result(0,0) += M(0,0);
for(i = 1; i < M.size2(); i ++)
{
result(0,i) = result(0, i-1) + M(0,i);
}
}
else if(M.size2() == 1)
{
int i = 0;
result(0,0) = M(0,0);
for(i = 1; i < M.size2(); i ++)
{
result(i,0) = result(i-1,0) + M(i,0);
}
}
return result;
}
MatrixD cumsum2(const std::vector<double>& V)
{
MatrixD result(1, V.size());
int i = 0;
result(0,0) += V[0];
//result(0,0) = V[0];
for(i = 1; i < V.size(); i ++)
{
result(0,i) = result(0, i-1) + V[i];
}
return result;
}
void printMatrixD(MatrixD mat, int rows, int cols, int dec) {
std::cout << std::fixed << std::setprecision(dec);
for(int r = 0; r < rows; r++) {
for(int c = 0; c < cols; c++) {
std::cout << mat(r, c) << '\t';
}
std::cout << '\n';
}
}
// returns the sum of all the elements
double sum(const MatrixD& M)
{
double result = 0;
int m = M.size1();
int n = M.size2();
int i,j;
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
result += M(i,j);
}
}
return result;
}
////////////////////////////////////////////
// init a matrix monotonically increasing
// steps of 1 from [start , end ] (inclusive)
MatrixD init_matrix_mti(int start, int end)
{
int len = end - start + 1;
MatrixD M(1, len);
int i;
for(i=0; i < len ; i++)
{
M(0,i) = start + i;
}
return M;
}
// returns matrix initialized with ones
MatrixD ones(int nrows, int ncols)
{
return init_matrix(nrows, ncols, 1.0);
}
// returns matrix initialized with ones
MatrixD zeros(int nrows, int ncols)
{
return init_matrix(nrows, ncols, 0);
}
MatrixD init_matrix(int nrows, int ncols, double val)
{
MatrixD M(nrows, ncols);
int i,j;
for(i=0;i<M.size1();i++)
{
for(j=0;j<M.size2();j++)
{
M(i,j) = val;
}
}
return M;
}
int length(const MatrixD& M)
{
int l;
if(M.size1() > M.size2())
l = M.size1();
else
l = M.size2();
return l;
}
///////////////////////////////////////////////////////
// VERIFIED
MatrixD linspace(double x1, double x2, int num_elements)
{
MatrixD M(1,num_elements);
double x3 = (double)(num_elements - 1);
double step = (x2 - x1) / x3;
M(0,0) = x1;
int i = 0;
for(i = 1; i < M.size2(); i++)
{
M(0,i) = x1 + ((double)i*step);
}
return M;
}
//////////////////////////////////////////////////////////////
// load a cfg file and set GlobalParams based on contents
void LoadCfg(std::string file, GlobalParameters& GP)
{
ifstream in(file.c_str());
if (!in.is_open())
return;
typedef tokenizer< char_separator<char> > Tokenizer;
char_separator<char> sep(",");
}
/////////////////////////////////////////////////////////////////////
// expect a csv file of data
void LoadData(std::string file, boost::numeric::ublas::matrix<double>& M)
{
ifstream in(file.c_str());
if (!in.is_open())
return;
typedef tokenizer< char_separator<char> > Tokenizer;
char_separator<char> sep(",");
string line;
int nrows = 0;
int ncols = 0;
std::vector<string> vec;
// get the size first
while (std::getline(in,line))
{
Tokenizer tok(line, sep);
vec.assign(tok.begin(), tok.end());
ncols = vec.end() - vec.begin();
nrows++;
}
cout << "num rows = "<< nrows << " num cols = " << ncols << endl;
// create a matrix to hold data
matrix<double> Data(nrows, ncols);
// make second pass
in.clear();
in.seekg(0);
int r = 0;
while (std::getline(in,line))
{
Tokenizer tok(line, sep);
vec.assign(tok.begin(), tok.end());
int i = 0;
for(i=0; i < vec.size() ; i++)
{
Data(r, i) = ::strtod(vec[i].c_str(), 0);
}
r++;
}
M = Data;
}
double get_element(MatrixD M, int i, int j)
{
return M(i,j);
}
|
/*************************************************************************************
garlic-player: SMIL Player for Digital Signage
Copyright (C) 2016 Nikolaos Saghiadinos <ns@smil-control.com>
This file is part of the garlic-player source code
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License, version 3,
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*************************************************************************************/
#include <QQmlApplicationEngine>
#include "tools/logger.h"
#include "tools/resource_monitor.h"
#include "../player-common/cmdparser.h"
#include "../player-common/screen.h"
#if defined Q_OS_ANDROID
#include "Java2Cpp.h"
#include <QtWebView>
#else
#include <qtwebengineglobal.h>
#endif
#include "mainwindow.h"
void handleMessages(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
Logger& MyLogger = Logger::getInstance();
MyLogger.dispatchMessages(type, context, msg);
}
int main(int argc, char *argv[])
{
#if QT_VERSION < 0x059300
qputenv("QML_DISABLE_DISK_CACHE", "true"); // due to https://bugreports.qt.io/browse/QTBUG-56935
#endif
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts); // Raspberry and POT needs this http://thebugfreeblog.blogspot.de/2018/01/pot-570-with-qt-5100-built-for-armv8.html
QApplication app(argc, argv);
#if defined Q_OS_ANDROID
QtWebView::initialize();
QtAndroid::androidActivity().callMethod<void>("registerBroadcastReceiver");
setGlobalLibFaceForJava(MyLibFacade);
#endif
qmlRegisterType<LibFacade>("com.garlic.LibFacade", 1, 0, "LibFacade");
qmlRegisterType<ResourceMonitor>("com.garlic.ResourceMonitor", 1, 0, "ResourceMonitor");
LibFacade *MyLibFacade = new LibFacade();
QApplication::setApplicationName(MyLibFacade->getConfiguration()->getAppName());
QApplication::setApplicationVersion(MyLibFacade->getConfiguration()->getVersion());
QApplication::setApplicationDisplayName(MyLibFacade->getConfiguration()->getAppName());
QDir dir(".");
MyLibFacade->getConfiguration()->determineBasePath(dir.absolutePath()); // When run in terminal absolute path returns user homedirectory in QtCreator
MyLibFacade->getConfiguration()->createDirectories();
qInstallMessageHandler(handleMessages);
TCmdParser MyParser(MyLibFacade);
MyParser.addOptions();
if (!MyParser.parse(&app))
return 1;
QLoggingCategory::setFilterRules("*.debug=true\nqt.*=false");
TScreen MyScreen(Q_NULLPTR);
MainWindow w(&MyScreen, MyLibFacade);
QQmlEngine::setObjectOwnership(&w, QQmlEngine::CppOwnership);
if (MyLibFacade->getConfiguration()->getIndexUri() == "" && w.openConfigDialog() == QDialog::Rejected)
return 0;
w.init();
#if defined Q_OS_ANDROID
// preserve android screensaver https://stackoverflow.com/questions/44100627/how-to-disable-screensaver-on-qt-android-app
// https://forum.qt.io/topic/57625/solved-keep-android-5-screen-on
QAndroidJniObject activity = QAndroidJniObject::callStaticObjectMethod("org/qtproject/qt5/android/QtNative", "activity", "()Landroid/app/Activity;");
if (activity.isValid())
{
QAndroidJniObject window = activity.callObjectMethod("getWindow", "()Landroid/view/Window;");
if (window.isValid())
{
const int FLAG_KEEP_SCREEN_ON = 128;
window.callMethod<void>("addFlags", "(I)V", FLAG_KEEP_SCREEN_ON);
}
}
// not to crash in Android > 5.x Clear any possible pending exceptions.
QAndroidJniEnvironment env;
if (env->ExceptionCheck()) {
env->ExceptionClear();
}
w.showFullScreen();
#else
w.show();
QString val = MyParser.getWindowMode();
if (val == "fullscreen")
w.resizeAsNormalFullScreen();
else if (val == "bigscreen")
w.resizeAsBigFullScreen();
else if (val == "windowed")
{
w.setMainWindowSize(MyParser.getWindowSize());
w.resizeAsWindow();
}
#endif
return app.exec();
}
Fix Bug fr Android
/*************************************************************************************
garlic-player: SMIL Player for Digital Signage
Copyright (C) 2016 Nikolaos Saghiadinos <ns@smil-control.com>
This file is part of the garlic-player source code
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License, version 3,
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*************************************************************************************/
#include <QQmlApplicationEngine>
#include "tools/logger.h"
#include "tools/resource_monitor.h"
#include "../player-common/cmdparser.h"
#include "../player-common/screen.h"
#if defined Q_OS_ANDROID
#include "Java2Cpp.h"
#include <QtWebView>
#else
#include <qtwebengineglobal.h>
#endif
#include "mainwindow.h"
void handleMessages(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
Logger& MyLogger = Logger::getInstance();
MyLogger.dispatchMessages(type, context, msg);
}
int main(int argc, char *argv[])
{
#if QT_VERSION < 0x059300
qputenv("QML_DISABLE_DISK_CACHE", "true"); // due to https://bugreports.qt.io/browse/QTBUG-56935
#endif
QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts); // Raspberry and POT needs this http://thebugfreeblog.blogspot.de/2018/01/pot-570-with-qt-5100-built-for-armv8.html
QApplication app(argc, argv);
LibFacade *MyLibFacade = new LibFacade();
#if defined Q_OS_ANDROID
QtWebView::initialize();
QtAndroid::androidActivity().callMethod<void>("registerBroadcastReceiver");
setGlobalLibFaceForJava(MyLibFacade);
#endif
qmlRegisterType<LibFacade>("com.garlic.LibFacade", 1, 0, "LibFacade");
qmlRegisterType<ResourceMonitor>("com.garlic.ResourceMonitor", 1, 0, "ResourceMonitor");
QApplication::setApplicationName(MyLibFacade->getConfiguration()->getAppName());
QApplication::setApplicationVersion(MyLibFacade->getConfiguration()->getVersion());
QApplication::setApplicationDisplayName(MyLibFacade->getConfiguration()->getAppName());
QDir dir(".");
MyLibFacade->getConfiguration()->determineBasePath(dir.absolutePath()); // When run in terminal absolute path returns user homedirectory in QtCreator
MyLibFacade->getConfiguration()->createDirectories();
qInstallMessageHandler(handleMessages);
TCmdParser MyParser(MyLibFacade);
MyParser.addOptions();
if (!MyParser.parse(&app))
return 1;
QLoggingCategory::setFilterRules("*.debug=true\nqt.*=false");
TScreen MyScreen(Q_NULLPTR);
MainWindow w(&MyScreen, MyLibFacade);
QQmlEngine::setObjectOwnership(&w, QQmlEngine::CppOwnership);
if (MyLibFacade->getConfiguration()->getIndexUri() == "" && w.openConfigDialog() == QDialog::Rejected)
return 0;
w.init();
#if defined Q_OS_ANDROID
// preserve android screensaver https://stackoverflow.com/questions/44100627/how-to-disable-screensaver-on-qt-android-app
// https://forum.qt.io/topic/57625/solved-keep-android-5-screen-on
QAndroidJniObject activity = QAndroidJniObject::callStaticObjectMethod("org/qtproject/qt5/android/QtNative", "activity", "()Landroid/app/Activity;");
if (activity.isValid())
{
QAndroidJniObject window = activity.callObjectMethod("getWindow", "()Landroid/view/Window;");
if (window.isValid())
{
const int FLAG_KEEP_SCREEN_ON = 128;
window.callMethod<void>("addFlags", "(I)V", FLAG_KEEP_SCREEN_ON);
}
}
// not to crash in Android > 5.x Clear any possible pending exceptions.
QAndroidJniEnvironment env;
if (env->ExceptionCheck()) {
env->ExceptionClear();
}
w.showFullScreen();
#else
w.show();
QString val = MyParser.getWindowMode();
if (val == "fullscreen")
w.resizeAsNormalFullScreen();
else if (val == "bigscreen")
w.resizeAsBigFullScreen();
else if (val == "windowed")
{
w.setMainWindowSize(MyParser.getWindowSize());
w.resizeAsWindow();
}
#endif
return app.exec();
}
|
#include "GraphicsDevice.h"
#include "EffekseerRendererGL.Base.h"
#include "EffekseerRendererGL.GLExtension.h"
#ifdef __ANDROID__
#ifdef __ANDROID__DEBUG__
#include "android/log.h"
#define LOG(s) __android_log_print(ANDROID_LOG_DEBUG, "Tag", "%s", s)
#else
#define LOG(s) printf("%s", s)
#endif
#elif defined(_WIN32)
#include <windows.h>
#define LOG(s) OutputDebugStringA(s)
#else
#define LOG(s) printf("%s", s)
#endif
#undef min
namespace EffekseerRendererGL
{
namespace Backend
{
void DeviceObject::OnLostDevice()
{
}
void DeviceObject::OnResetDevice()
{
}
VertexBuffer::VertexBuffer(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
graphicsDevice_->Register(this);
}
VertexBuffer::~VertexBuffer()
{
graphicsDevice_->Unregister(this);
ES_SAFE_RELEASE(graphicsDevice_);
}
bool VertexBuffer::Allocate(int32_t size, bool isDynamic)
{
resources_.resize(static_cast<size_t>(size));
GLExt::glGenBuffers(1, &buffer_);
int arrayBufferBinding = 0;
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBufferBinding);
GLExt::glBindBuffer(GL_ARRAY_BUFFER, buffer_);
GLExt::glBufferData(GL_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), nullptr, isDynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
GLExt::glBindBuffer(GL_ARRAY_BUFFER, arrayBufferBinding);
return true;
}
void VertexBuffer::Deallocate()
{
if (buffer_ == 0)
{
GLExt::glDeleteBuffers(1, &buffer_);
buffer_ = 0;
}
}
void VertexBuffer::OnLostDevice()
{
Deallocate();
}
void VertexBuffer::OnResetDevice()
{
Allocate(size_, isDynamic_);
}
bool VertexBuffer::Init(int32_t size, bool isDynamic)
{
size_ = size;
isDynamic_ = isDynamic;
return Allocate(size_, isDynamic_);
}
void VertexBuffer::UpdateData(const void* src, int32_t size, int32_t offset)
{
bool isSupportedBufferRange = GLExt::IsSupportedBufferRange();
#ifdef __ANDROID__
isSupportedBufferRange = false;
#endif
int arrayBufferBinding = 0;
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBufferBinding);
GLExt::glBindBuffer(GL_ARRAY_BUFFER, buffer_);
if (isSupportedBufferRange)
{
auto target = GLExt::glMapBufferRange(GL_ARRAY_BUFFER, offset, size, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
memcpy(target, src, size);
GLExt::glUnmapBuffer(GL_ARRAY_BUFFER);
}
else
{
memcpy(resources_.data() + offset, src, size);
GLExt::glBufferData(GL_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), resources_.data(), isDynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
}
GLExt::glBindBuffer(GL_ARRAY_BUFFER, arrayBufferBinding);
}
IndexBuffer::IndexBuffer(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
graphicsDevice_->Register(this);
}
IndexBuffer::~IndexBuffer()
{
graphicsDevice_->Unregister(this);
ES_SAFE_RELEASE(graphicsDevice_);
}
bool IndexBuffer::Allocate(int32_t elementCount, int32_t stride)
{
resources_.resize(elementCount_ * stride_);
GLExt::glGenBuffers(1, &buffer_);
int elementArrayBufferBinding = 0;
glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &elementArrayBufferBinding);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_);
GLExt::glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), nullptr, GL_STATIC_DRAW);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBufferBinding);
elementCount_ = elementCount;
strideType_ = stride == 4 ? Effekseer::Backend::IndexBufferStrideType::Stride4 : Effekseer::Backend::IndexBufferStrideType::Stride2;
return true;
}
void IndexBuffer::Deallocate()
{
if (buffer_ == 0)
{
GLExt::glDeleteBuffers(1, &buffer_);
buffer_ = 0;
}
}
void IndexBuffer::OnLostDevice()
{
Deallocate();
}
void IndexBuffer::OnResetDevice()
{
Allocate(elementCount_, stride_);
}
bool IndexBuffer::Init(int32_t elementCount, int32_t stride)
{
elementCount_ = elementCount;
stride_ = stride;
return Allocate(elementCount_, stride_);
}
void IndexBuffer::UpdateData(const void* src, int32_t size, int32_t offset)
{
memcpy(resources_.data() + offset, src, size);
int elementArrayBufferBinding = 0;
glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &elementArrayBufferBinding);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_);
GLExt::glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), resources_.data(), GL_STATIC_DRAW);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBufferBinding);
}
bool UniformBuffer::Init(int32_t size, const void* initialData)
{
buffer_.resize(size);
if (auto data = static_cast<const uint8_t*>(initialData))
{
buffer_.assign(data, data + size);
}
return true;
}
void UniformBuffer::UpdateData(const void* src, int32_t size, int32_t offset)
{
assert(buffer_.size() >= size + offset && offset >= 0);
buffer_.resize(size);
if (auto data = static_cast<const uint8_t*>(src))
{
memcpy(buffer_.data() + offset, src, size);
}
}
Texture::Texture(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
}
Texture::~Texture()
{
if (onDisposed_)
{
onDisposed_();
}
else
{
if (buffer_ > 0)
{
glDeleteTextures(1, &buffer_);
buffer_ = 0;
}
}
ES_SAFE_RELEASE(graphicsDevice_);
}
bool Texture::InitInternal(const Effekseer::Backend::TextureParameter& param)
{
if (graphicsDevice_->GetDeviceType() == OpenGLDeviceType::OpenGL2 || graphicsDevice_->GetDeviceType() == OpenGLDeviceType::OpenGLES2)
{
if ((param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM ||
param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM_SRGB))
{
// not supported
return false;
}
}
GLint bound = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound);
glGenTextures(1, &buffer_);
glBindTexture(GL_TEXTURE_2D, buffer_);
// Compressed texture
auto isCompressed = param.Format == Effekseer::Backend::TextureFormatType::BC1 ||
param.Format == Effekseer::Backend::TextureFormatType::BC2 ||
param.Format == Effekseer::Backend::TextureFormatType::BC3 ||
param.Format == Effekseer::Backend::TextureFormatType::BC1_SRGB ||
param.Format == Effekseer::Backend::TextureFormatType::BC2_SRGB ||
param.Format == Effekseer::Backend::TextureFormatType::BC3_SRGB;
const size_t initialDataSize = param.InitialData.size();
const void* initialDataPtr = param.InitialData.size() > 0 ? param.InitialData.data() : nullptr;
if (isCompressed)
{
GLenum format = GL_RGBA;
if (param.Format == Effekseer::Backend::TextureFormatType::BC1)
{
format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC2)
{
format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC3)
{
format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC1_SRGB)
{
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC2_SRGB)
{
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC3_SRGB)
{
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
}
GLExt::glCompressedTexImage2D(GL_TEXTURE_2D,
0,
format,
param.Size[0],
param.Size[1],
0,
static_cast<GLsizei>(initialDataSize),
initialDataPtr);
}
else
{
GLuint internalFormat = GL_RGBA;
GLenum format = GL_RGBA;
GLenum type = GL_UNSIGNED_BYTE;
if (param.Format == Effekseer::Backend::TextureFormatType::R8G8B8A8_UNORM)
{
internalFormat = GL_RGBA;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM)
{
internalFormat = GL_RGBA;
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R8G8B8A8_UNORM_SRGB)
{
internalFormat = GL_SRGB8_ALPHA8;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM_SRGB)
{
internalFormat = GL_SRGB8_ALPHA8;
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R8_UNORM)
{
internalFormat = GL_R8;
format = GL_RED;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R16G16_FLOAT)
{
internalFormat = GL_RG16F;
format = GL_RG;
type = GL_HALF_FLOAT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R16G16B16A16_FLOAT)
{
internalFormat = GL_RGBA16F;
format = GL_RGBA;
type = GL_HALF_FLOAT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R32G32B32A32_FLOAT)
{
internalFormat = GL_RGBA32F;
format = GL_RGBA;
type = GL_FLOAT;
}
glTexImage2D(GL_TEXTURE_2D,
0,
internalFormat,
param.Size[0],
param.Size[1],
0,
format,
type,
initialDataPtr);
}
if (param.GenerateMipmap)
{
GLExt::glGenerateMipmap(GL_TEXTURE_2D);
}
glBindTexture(GL_TEXTURE_2D, bound);
size_ = param.Size;
format_ = param.Format;
hasMipmap_ = param.GenerateMipmap;
return true;
}
bool Texture::Init(const Effekseer::Backend::TextureParameter& param)
{
auto ret = InitInternal(param);
type_ = Effekseer::Backend::TextureType::Color2D;
return ret;
}
bool Texture::Init(const Effekseer::Backend::RenderTextureParameter& param)
{
Effekseer::Backend::TextureParameter paramInternal;
paramInternal.Size = param.Size;
paramInternal.Format = param.Format;
paramInternal.GenerateMipmap = false;
auto ret = Init(paramInternal);
type_ = Effekseer::Backend::TextureType::Render;
return ret;
}
bool Texture::Init(const Effekseer::Backend::DepthTextureParameter& param)
{
GLint bound = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound);
glGenTextures(1, &buffer_);
glBindTexture(GL_TEXTURE_2D, buffer_);
if (param.Format == Effekseer::Backend::TextureFormatType::D24S8)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, param.Size[0], param.Size[1], 0, GL_DEPTH_STENCIL, GL_FLOAT, nullptr);
}
else if (param.Format == Effekseer::Backend::TextureFormatType::D32S8)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH32F_STENCIL8, param.Size[0], param.Size[1], 0, GL_DEPTH_STENCIL, GL_FLOAT, nullptr);
}
else if (param.Format == Effekseer::Backend::TextureFormatType::D32S8)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, param.Size[0], param.Size[1], 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
}
else
{
glDeleteTextures(1, &buffer_);
buffer_ = 0;
glBindTexture(GL_TEXTURE_2D, bound);
return false;
}
glBindTexture(GL_TEXTURE_2D, bound);
size_ = param.Size;
format_ = param.Format;
hasMipmap_ = false;
type_ = Effekseer::Backend::TextureType::Depth;
return true;
}
bool Texture::Init(GLuint buffer, const std::function<void()>& onDisposed)
{
if (buffer == 0)
return false;
buffer_ = buffer;
onDisposed_ = onDisposed;
hasMipmap_ = false;
type_ = Effekseer::Backend::TextureType::Color2D;
return true;
}
bool VertexLayout::Init(const Effekseer::Backend::VertexLayoutElement* elements, int32_t elementCount)
{
elements_.resize(elementCount);
for (int32_t i = 0; i < elementCount; i++)
{
elements_[i] = elements[i];
}
return true;
}
Shader::Shader(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
}
Shader::~Shader()
{
if (program_ > 0)
{
GLExt::glDeleteProgram(program_);
}
if (vao_ > 0)
{
GLExt::glDeleteVertexArrays(1, &vao_);
}
ES_SAFE_RELEASE(graphicsDevice_);
}
bool Shader::Init(const char* vsCode, const char* psCode, Effekseer::Backend::UniformLayoutRef& layout)
{
GLint vsCodeLen = static_cast<GLint>(strlen(vsCode));
GLint psCodeLen = static_cast<GLint>(strlen(psCode));
GLint res_vs, res_fs, res_link = 0;
auto vert_shader = GLExt::glCreateShader(GL_VERTEX_SHADER);
GLExt::glShaderSource(vert_shader, 1, &vsCode, &vsCodeLen);
GLExt::glCompileShader(vert_shader);
GLExt::glGetShaderiv(vert_shader, GL_COMPILE_STATUS, &res_vs);
auto frag_shader = GLExt::glCreateShader(GL_FRAGMENT_SHADER);
GLExt::glShaderSource(frag_shader, 1, &psCode, &psCodeLen);
GLExt::glCompileShader(frag_shader);
GLExt::glGetShaderiv(frag_shader, GL_COMPILE_STATUS, &res_fs);
// create shader program
auto program = GLExt::glCreateProgram();
GLExt::glAttachShader(program, vert_shader);
GLExt::glAttachShader(program, frag_shader);
// link shaders
GLExt::glLinkProgram(program);
GLExt::glGetProgramiv(program, GL_LINK_STATUS, &res_link);
#ifndef NDEBUG
if (res_link == GL_FALSE)
{
// output errors
char log[512];
int32_t log_size;
GLExt::glGetShaderInfoLog(vert_shader, sizeof(log), &log_size, log);
if (log_size > 0)
{
LOG(": Vertex Shader error.\n");
LOG(log);
}
GLExt::glGetShaderInfoLog(frag_shader, sizeof(log), &log_size, log);
if (log_size > 0)
{
LOG(": Fragment Shader error.\n");
LOG(log);
}
GLExt::glGetProgramInfoLog(program, sizeof(log), &log_size, log);
if (log_size > 0)
{
LOG(": Shader Link error.\n");
LOG(log);
}
}
#endif
// dispose shader objects
GLExt::glDeleteShader(frag_shader);
GLExt::glDeleteShader(vert_shader);
if (res_link == GL_FALSE)
{
GLExt::glDeleteProgram(program);
return false;
}
program_ = program;
if (GLExt::IsSupportedVertexArray())
{
GLExt::glGenVertexArrays(1, &vao_);
}
layout_ = layout;
return true;
}
bool PipelineState::Init(const Effekseer::Backend::PipelineStateParameter& param)
{
param_ = param;
return true;
}
RenderPass::RenderPass(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
}
RenderPass::~RenderPass()
{
if (buffer_ > 0)
{
GLExt::glDeleteFramebuffers(1, &buffer_);
buffer_ = 0;
}
ES_SAFE_RELEASE(graphicsDevice_);
}
bool RenderPass::Init(Effekseer::FixedSizeVector<Effekseer::Backend::TextureRef, Effekseer::Backend::RenderTargetMax>& textures, Effekseer::Backend::TextureRef depthTexture)
{
for (int32_t i = 0; i < textures.size(); i++)
{
if (textures.at(i) == nullptr)
{
Effekseer::Log(Effekseer::LogType::Error, "RenderPass : textures " + std::to_string(i) + " must not be null.");
return false;
}
if (textures.at(i)->GetTextureType() != Effekseer::Backend::TextureType::Render)
{
Effekseer::Log(Effekseer::LogType::Error, "RenderPass : textures " + std::to_string(i) + " must be Render.");
return false;
}
}
if (depthTexture != nullptr && depthTexture->GetTextureType() != Effekseer::Backend::TextureType::Depth)
{
Effekseer::Log(Effekseer::LogType::Error, "RenderPass : depthTexture must be Depth.");
return false;
}
textures_ = textures;
depthTexture_ = depthTexture;
GLExt::glGenFramebuffers(1, &buffer_);
if (buffer_ == 0)
{
return false;
}
GLint backupFramebuffer;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &backupFramebuffer);
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, buffer_);
for (int32_t i = 0; i < textures.size(); i++)
{
GLExt::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, static_cast<Texture*>(textures.at(i).Get())->GetBuffer(), 0);
}
if (depthTexture != nullptr)
{
GLExt::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, static_cast<Texture*>(depthTexture.Get())->GetBuffer(), 0);
}
textures_ = textures;
depthTexture_ = depthTexture;
const GLenum bufs[] = {
GL_COLOR_ATTACHMENT0,
GL_COLOR_ATTACHMENT1,
GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3,
};
GLExt::glDrawBuffers(textures.size(), bufs);
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, backupFramebuffer);
return true;
}
GraphicsDevice::GraphicsDevice(OpenGLDeviceType deviceType)
: deviceType_(deviceType)
{
GLExt::Initialize(deviceType);
if (deviceType == OpenGLDeviceType::OpenGL3 || deviceType == OpenGLDeviceType::OpenGLES3)
{
GLExt::glGenSamplers(Effekseer::TextureSlotMax, samplers_.data());
}
}
GraphicsDevice::~GraphicsDevice()
{
if (deviceType_ == OpenGLDeviceType::OpenGL3 || deviceType_ == OpenGLDeviceType::OpenGLES3)
{
GLExt::glDeleteSamplers(Effekseer::TextureSlotMax, samplers_.data());
}
}
void GraphicsDevice::LostDevice()
{
for (auto& o : objects_)
{
o->OnLostDevice();
}
}
void GraphicsDevice::ResetDevice()
{
for (auto& o : objects_)
{
o->OnResetDevice();
}
}
OpenGLDeviceType GraphicsDevice::GetDeviceType() const
{
return deviceType_;
}
void GraphicsDevice::Register(DeviceObject* deviceObject)
{
objects_.insert(deviceObject);
}
void GraphicsDevice::Unregister(DeviceObject* deviceObject)
{
objects_.erase(deviceObject);
}
Effekseer::Backend::VertexBufferRef GraphicsDevice::CreateVertexBuffer(int32_t size, const void* initialData, bool isDynamic)
{
auto ret = Effekseer::MakeRefPtr<VertexBuffer>(this);
if (!ret->Init(size, isDynamic))
{
return nullptr;
}
ret->UpdateData(initialData, size, 0);
return ret;
}
Effekseer::Backend::IndexBufferRef GraphicsDevice::CreateIndexBuffer(int32_t elementCount, const void* initialData, Effekseer::Backend::IndexBufferStrideType stride)
{
auto ret = Effekseer::MakeRefPtr<IndexBuffer>(this);
if (!ret->Init(elementCount, stride == Effekseer::Backend::IndexBufferStrideType::Stride4 ? 4 : 2))
{
return nullptr;
}
ret->UpdateData(initialData, elementCount * (stride == Effekseer::Backend::IndexBufferStrideType::Stride4 ? 4 : 2), 0);
return ret;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateTexture(const Effekseer::Backend::TextureParameter& param)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateRenderTexture(const Effekseer::Backend::RenderTextureParameter& param)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateDepthTexture(const Effekseer::Backend::DepthTextureParameter& param)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::UniformBufferRef GraphicsDevice::CreateUniformBuffer(int32_t size, const void* initialData)
{
auto ret = Effekseer::MakeRefPtr<UniformBuffer>();
if (!ret->Init(size, initialData))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::VertexLayoutRef GraphicsDevice::CreateVertexLayout(const Effekseer::Backend::VertexLayoutElement* elements, int32_t elementCount)
{
auto ret = Effekseer::MakeRefPtr<VertexLayout>();
if (!ret->Init(elements, elementCount))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::RenderPassRef GraphicsDevice::CreateRenderPass(Effekseer::FixedSizeVector<Effekseer::Backend::TextureRef, Effekseer::Backend::RenderTargetMax>& textures, Effekseer::Backend::TextureRef& depthTexture)
{
auto ret = Effekseer::MakeRefPtr<RenderPass>(this);
if (!ret->Init(textures, depthTexture))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::PipelineStateRef GraphicsDevice::CreatePipelineState(const Effekseer::Backend::PipelineStateParameter& param)
{
auto ret = Effekseer::MakeRefPtr<PipelineState>();
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::ShaderRef GraphicsDevice::CreateShaderFromKey(const char* key)
{
return nullptr;
}
Effekseer::Backend::ShaderRef GraphicsDevice::CreateShaderFromCodes(const char* vsCode, const char* psCode, Effekseer::Backend::UniformLayoutRef layout)
{
auto ret = Effekseer::MakeRefPtr<Shader>(this);
if (!ret->Init(vsCode, psCode, layout))
{
return nullptr;
}
return ret;
}
void GraphicsDevice::Draw(const Effekseer::Backend::DrawParameter& drawParam)
{
if (drawParam.VertexBufferPtr == nullptr ||
drawParam.IndexBufferPtr == nullptr ||
drawParam.PipelineStatePtr == nullptr)
{
return;
}
auto pip = static_cast<PipelineState*>(drawParam.PipelineStatePtr.Get());
auto shader = static_cast<Shader*>(pip->GetParam().ShaderPtr.Get());
auto vertexLayout = static_cast<VertexLayout*>(pip->GetParam().VertexLayoutPtr.Get());
if (shader->GetLayout() == nullptr)
{
return;
}
GLint currentVAO = 0;
if (GLExt::IsSupportedVertexArray())
{
glGetIntegerv(GL_VERTEX_ARRAY_BINDING, ¤tVAO);
GLExt::glBindVertexArray(shader->GetVAO());
}
GLExt::glBindBuffer(GL_ARRAY_BUFFER, static_cast<VertexBuffer*>(drawParam.VertexBufferPtr.Get())->GetBuffer());
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, static_cast<IndexBuffer*>(drawParam.IndexBufferPtr.Get())->GetBuffer());
GLExt::glUseProgram(shader->GetProgram());
// textures
auto textureCount = std::min(static_cast<int32_t>(shader->GetLayout()->GetTextures().size()), drawParam.TextureCount);
for (int32_t i = 0; i < textureCount; i++)
{
auto textureSlot = GLExt::glGetUniformLocation(shader->GetProgram(), shader->GetLayout()->GetTextures()[i].c_str());
if (textureSlot < 0)
{
continue;
}
GLExt::glUniform1i(textureSlot, i);
auto texture = static_cast<Texture*>(drawParam.TexturePtrs[i].Get());
if (texture != nullptr)
{
GLExt::glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, texture->GetBuffer());
static const GLint glfilterMin[] = {GL_NEAREST, GL_LINEAR_MIPMAP_LINEAR};
static const GLint glfilterMin_NoneMipmap[] = {GL_NEAREST, GL_LINEAR};
static const GLint glfilterMag[] = {GL_NEAREST, GL_LINEAR};
static const GLint glwrap[] = {GL_REPEAT, GL_CLAMP_TO_EDGE};
GLint filterMin = 0;
GLint filterMag = 0;
GLint wrap = 0;
if (drawParam.TextureSamplingTypes[i] == Effekseer::Backend::TextureSamplingType::Linear)
{
if (texture->GetHasMipmap())
{
filterMin = glfilterMin[1];
}
else
{
filterMin = glfilterMin_NoneMipmap[1];
}
filterMag = glfilterMag[1];
}
else
{
if (texture->GetHasMipmap())
{
filterMin = glfilterMin[0];
}
else
{
filterMin = glfilterMin_NoneMipmap[0];
}
filterMag = glfilterMag[0];
}
if (drawParam.TextureWrapTypes[i] == Effekseer::Backend::TextureWrapType::Clamp)
{
wrap = glwrap[1];
}
else
{
wrap = glwrap[0];
}
if (deviceType_ == OpenGLDeviceType::OpenGL3 || deviceType_ == OpenGLDeviceType::OpenGLES3)
{
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_MAG_FILTER, filterMag);
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_MIN_FILTER, filterMin);
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_WRAP_S, wrap);
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_WRAP_T, wrap);
GLExt::glBindSampler(i, samplers_[i]);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterMag);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterMin);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap);
}
}
}
// uniformss
for (size_t i = 0; i < shader->GetLayout()->GetElements().size(); i++)
{
const auto& element = shader->GetLayout()->GetElements()[i];
auto loc = GLExt::glGetUniformLocation(shader->GetProgram(), element.Name.c_str());
if (loc < 0)
{
continue;
}
UniformBuffer* uniformBuffer = nullptr;
if (element.Stage == Effekseer::Backend::ShaderStageType::Vertex)
{
uniformBuffer = static_cast<UniformBuffer*>(drawParam.VertexUniformBufferPtr.Get());
}
else if (element.Stage == Effekseer::Backend::ShaderStageType::Pixel)
{
uniformBuffer = static_cast<UniformBuffer*>(drawParam.PixelUniformBufferPtr.Get());
}
if (uniformBuffer != nullptr)
{
if (element.Type == Effekseer::Backend::UniformBufferLayoutElementType::Vector4)
{
const auto& buffer = uniformBuffer->GetBuffer();
assert(buffer.size() >= element.Offset + sizeof(float) * 4);
GLExt::glUniform4fv(loc, 1, reinterpret_cast<const GLfloat*>(buffer.data() + element.Offset));
}
else if (element.Type == Effekseer::Backend::UniformBufferLayoutElementType::Matrix44)
{
const auto& buffer = uniformBuffer->GetBuffer();
assert(buffer.size() >= element.Offset + sizeof(float) * 4 * 4);
GLExt::glUniformMatrix4fv(loc, 1, GL_FALSE, reinterpret_cast<const GLfloat*>(buffer.data() + element.Offset));
}
else
{
// Unimplemented
assert(0);
}
}
else
{
// Invalid
assert(0);
}
}
GLCheckError();
// layouts
{
int32_t vertexSize = 0;
for (size_t i = 0; i < vertexLayout->GetElements().size(); i++)
{
const auto& element = vertexLayout->GetElements()[i];
vertexSize += Effekseer::Backend::GetVertexLayoutFormatSize(element.Format);
}
uint16_t offset = 0;
for (size_t i = 0; i < vertexLayout->GetElements().size(); i++)
{
const auto& element = vertexLayout->GetElements()[i];
auto loc = GLExt::glGetAttribLocation(shader->GetProgram(), element.Name.c_str());
GLenum type = {};
int32_t count = {};
GLboolean isNormalized = false;
if (element.Format == Effekseer::Backend::VertexLayoutFormat::R8G8B8A8_UINT)
{
count = 4;
type = GL_UNSIGNED_BYTE;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R8G8B8A8_UNORM)
{
count = 4;
type = GL_UNSIGNED_BYTE;
isNormalized = GL_TRUE;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32_FLOAT)
{
count = 1;
type = GL_FLOAT;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32G32_FLOAT)
{
count = 2;
type = GL_FLOAT;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32G32B32_FLOAT)
{
count = 3;
type = GL_FLOAT;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32G32B32A32_FLOAT)
{
count = 4;
type = GL_FLOAT;
}
else
{
assert(0);
}
if (loc >= 0)
{
GLExt::glEnableVertexAttribArray(loc);
GLExt::glVertexAttribPointer(loc,
count,
type,
isNormalized,
vertexSize,
reinterpret_cast<GLvoid*>(offset));
}
offset += Effekseer::Backend::GetVertexLayoutFormatSize(element.Format);
}
}
GLCheckError();
// States
GLint frontFace = 0;
glGetIntegerv(GL_FRONT_FACE, &frontFace);
if (GL_CW == frontFace)
{
if (pip->GetParam().Culling == Effekseer::Backend::CullingType::Clockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::CounterClockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::DoubleSide)
{
glDisable(GL_CULL_FACE);
glCullFace(GL_FRONT_AND_BACK);
}
}
else
{
if (pip->GetParam().Culling == Effekseer::Backend::CullingType::Clockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::CounterClockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::DoubleSide)
{
glDisable(GL_CULL_FACE);
glCullFace(GL_FRONT_AND_BACK);
}
}
GLCheckError();
{
if (pip->GetParam().IsDepthTestEnabled || pip->GetParam().IsDepthWriteEnabled)
{
glEnable(GL_DEPTH_TEST);
}
else
{
glDisable(GL_DEPTH_TEST);
}
if (pip->GetParam().IsDepthTestEnabled)
{
std::array<GLenum, 8> depthFuncs;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Less)] = GL_LESS;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::LessEqual)] = GL_LEQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::NotEqual)] = GL_NOTEQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Equal)] = GL_EQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Greater)] = GL_GREATER;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::GreaterEqual)] = GL_GEQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Never)] = GL_NEVER;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Always)] = GL_ALWAYS;
glDepthFunc(depthFuncs[static_cast<int>(pip->GetParam().DepthFunc)]);
}
else
{
glDepthFunc(GL_ALWAYS);
}
glDepthMask(pip->GetParam().IsDepthWriteEnabled);
}
{
if (pip->GetParam().IsBlendEnabled)
{
glEnable(GL_BLEND);
std::array<GLenum, 5> blendEq;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Add)] = GL_FUNC_ADD;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Sub)] = GL_FUNC_SUBTRACT;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::ReverseSub)] = GL_FUNC_REVERSE_SUBTRACT;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Min)] = GL_MIN;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Max)] = GL_MAX;
std::array<GLenum, 10> blendFunc;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::Zero)] = GL_ZERO;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::One)] = GL_ONE;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::SrcColor)] = GL_SRC_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusSrcColor)] = GL_ONE_MINUS_SRC_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::SrcAlpha)] = GL_SRC_ALPHA;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusSrcAlpha)] = GL_ONE_MINUS_SRC_ALPHA;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::DstColor)] = GL_DST_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusDstColor)] = GL_ONE_MINUS_DST_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::DstAlpha)] = GL_DST_ALPHA;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusDstAlpha)] = GL_ONE_MINUS_DST_ALPHA;
GLExt::glBlendEquationSeparate(blendEq[static_cast<int>(pip->GetParam().BlendEquationRGB)], blendEq[static_cast<int>(pip->GetParam().BlendEquationAlpha)]);
GLExt::glBlendFuncSeparate(blendFunc[static_cast<int>(pip->GetParam().BlendSrcFunc)], blendFunc[static_cast<int>(pip->GetParam().BlendDstFunc)], blendFunc[static_cast<int>(pip->GetParam().BlendSrcFuncAlpha)], blendFunc[static_cast<int>(pip->GetParam().BlendDstFuncAlpha)]);
}
else
{
glDisable(GL_BLEND);
}
}
GLCheckError();
GLenum primitiveMode = {};
GLenum indexStrideType = {};
int32_t indexPerPrimitive = {};
if (pip->GetParam().Topology == Effekseer::Backend::TopologyType::Triangle)
{
primitiveMode = GL_TRIANGLES;
indexPerPrimitive = 3;
}
else if (pip->GetParam().Topology == Effekseer::Backend::TopologyType::Line)
{
primitiveMode = GL_LINES;
indexPerPrimitive = 2;
}
else if (pip->GetParam().Topology == Effekseer::Backend::TopologyType::Point)
{
primitiveMode = GL_POINTS;
indexPerPrimitive = 1;
}
if (drawParam.IndexBufferPtr->GetStrideType() == Effekseer::Backend::IndexBufferStrideType::Stride4)
{
indexStrideType = GL_UNSIGNED_INT;
}
else if (drawParam.IndexBufferPtr->GetStrideType() == Effekseer::Backend::IndexBufferStrideType::Stride2)
{
indexStrideType = GL_UNSIGNED_SHORT;
}
if (drawParam.InstanceCount > 1)
{
GLExt::glDrawElementsInstanced(primitiveMode, indexPerPrimitive * drawParam.PrimitiveCount, indexStrideType, nullptr, drawParam.PrimitiveCount);
}
else
{
glDrawElements(primitiveMode, indexPerPrimitive * drawParam.PrimitiveCount, indexStrideType, nullptr);
}
for (size_t i = 0; i < vertexLayout->GetElements().size(); i++)
{
const auto& element = vertexLayout->GetElements()[i];
auto loc = GLExt::glGetAttribLocation(shader->GetProgram(), element.Name.c_str());
if (loc >= 0)
{
GLExt::glDisableVertexAttribArray(loc);
}
}
if (GLExt::IsSupportedVertexArray())
{
GLExt::glBindVertexArray(currentVAO);
}
GLCheckError();
}
void GraphicsDevice::BeginRenderPass(Effekseer::Backend::RenderPassRef& renderPass, bool isColorCleared, bool isDepthCleared, Effekseer::Color clearColor)
{
if (renderPass != nullptr)
{
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, static_cast<RenderPass*>(renderPass.Get())->GetBuffer());
}
else
{
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, 0);
glDrawBuffer(GL_BACK);
}
GLbitfield flag = 0;
if (isColorCleared)
{
flag |= GL_COLOR_BUFFER_BIT;
glClearColor(clearColor.R / 255.0f, clearColor.G / 255.0f, clearColor.B / 255.0f, clearColor.A / 255.0f);
GLCheckError();
}
if (isDepthCleared)
{
flag |= GL_DEPTH_BUFFER_BIT;
}
if (flag != 0)
{
glClear(flag);
}
GLCheckError();
}
void GraphicsDevice::EndRenderPass()
{
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLCheckError();
}
bool GraphicsDevice::UpdateUniformBuffer(Effekseer::Backend::UniformBufferRef& buffer, int32_t size, int32_t offset, const void* data)
{
if (buffer == nullptr)
{
return false;
}
auto b = static_cast<UniformBuffer*>(buffer.Get());
b->UpdateData(data, size, offset);
return true;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateTexture(GLuint buffer, const std::function<void()>& onDisposed)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(buffer, onDisposed))
{
return nullptr;
}
return ret;
}
} // namespace Backend
} // namespace EffekseerRendererGL
Fix a compile on webgl
#include "GraphicsDevice.h"
#include "EffekseerRendererGL.Base.h"
#include "EffekseerRendererGL.GLExtension.h"
#ifdef __ANDROID__
#ifdef __ANDROID__DEBUG__
#include "android/log.h"
#define LOG(s) __android_log_print(ANDROID_LOG_DEBUG, "Tag", "%s", s)
#else
#define LOG(s) printf("%s", s)
#endif
#elif defined(_WIN32)
#include <windows.h>
#define LOG(s) OutputDebugStringA(s)
#else
#define LOG(s) printf("%s", s)
#endif
#undef min
namespace EffekseerRendererGL
{
namespace Backend
{
void DeviceObject::OnLostDevice()
{
}
void DeviceObject::OnResetDevice()
{
}
VertexBuffer::VertexBuffer(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
graphicsDevice_->Register(this);
}
VertexBuffer::~VertexBuffer()
{
graphicsDevice_->Unregister(this);
ES_SAFE_RELEASE(graphicsDevice_);
}
bool VertexBuffer::Allocate(int32_t size, bool isDynamic)
{
resources_.resize(static_cast<size_t>(size));
GLExt::glGenBuffers(1, &buffer_);
int arrayBufferBinding = 0;
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBufferBinding);
GLExt::glBindBuffer(GL_ARRAY_BUFFER, buffer_);
GLExt::glBufferData(GL_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), nullptr, isDynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
GLExt::glBindBuffer(GL_ARRAY_BUFFER, arrayBufferBinding);
return true;
}
void VertexBuffer::Deallocate()
{
if (buffer_ == 0)
{
GLExt::glDeleteBuffers(1, &buffer_);
buffer_ = 0;
}
}
void VertexBuffer::OnLostDevice()
{
Deallocate();
}
void VertexBuffer::OnResetDevice()
{
Allocate(size_, isDynamic_);
}
bool VertexBuffer::Init(int32_t size, bool isDynamic)
{
size_ = size;
isDynamic_ = isDynamic;
return Allocate(size_, isDynamic_);
}
void VertexBuffer::UpdateData(const void* src, int32_t size, int32_t offset)
{
bool isSupportedBufferRange = GLExt::IsSupportedBufferRange();
#ifdef __ANDROID__
isSupportedBufferRange = false;
#endif
int arrayBufferBinding = 0;
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &arrayBufferBinding);
GLExt::glBindBuffer(GL_ARRAY_BUFFER, buffer_);
if (isSupportedBufferRange)
{
auto target = GLExt::glMapBufferRange(GL_ARRAY_BUFFER, offset, size, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
memcpy(target, src, size);
GLExt::glUnmapBuffer(GL_ARRAY_BUFFER);
}
else
{
memcpy(resources_.data() + offset, src, size);
GLExt::glBufferData(GL_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), resources_.data(), isDynamic_ ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
}
GLExt::glBindBuffer(GL_ARRAY_BUFFER, arrayBufferBinding);
}
IndexBuffer::IndexBuffer(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
graphicsDevice_->Register(this);
}
IndexBuffer::~IndexBuffer()
{
graphicsDevice_->Unregister(this);
ES_SAFE_RELEASE(graphicsDevice_);
}
bool IndexBuffer::Allocate(int32_t elementCount, int32_t stride)
{
resources_.resize(elementCount_ * stride_);
GLExt::glGenBuffers(1, &buffer_);
int elementArrayBufferBinding = 0;
glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &elementArrayBufferBinding);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_);
GLExt::glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), nullptr, GL_STATIC_DRAW);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBufferBinding);
elementCount_ = elementCount;
strideType_ = stride == 4 ? Effekseer::Backend::IndexBufferStrideType::Stride4 : Effekseer::Backend::IndexBufferStrideType::Stride2;
return true;
}
void IndexBuffer::Deallocate()
{
if (buffer_ == 0)
{
GLExt::glDeleteBuffers(1, &buffer_);
buffer_ = 0;
}
}
void IndexBuffer::OnLostDevice()
{
Deallocate();
}
void IndexBuffer::OnResetDevice()
{
Allocate(elementCount_, stride_);
}
bool IndexBuffer::Init(int32_t elementCount, int32_t stride)
{
elementCount_ = elementCount;
stride_ = stride;
return Allocate(elementCount_, stride_);
}
void IndexBuffer::UpdateData(const void* src, int32_t size, int32_t offset)
{
memcpy(resources_.data() + offset, src, size);
int elementArrayBufferBinding = 0;
glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &elementArrayBufferBinding);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer_);
GLExt::glBufferData(GL_ELEMENT_ARRAY_BUFFER, static_cast<uint32_t>(resources_.size()), resources_.data(), GL_STATIC_DRAW);
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBufferBinding);
}
bool UniformBuffer::Init(int32_t size, const void* initialData)
{
buffer_.resize(size);
if (auto data = static_cast<const uint8_t*>(initialData))
{
buffer_.assign(data, data + size);
}
return true;
}
void UniformBuffer::UpdateData(const void* src, int32_t size, int32_t offset)
{
assert(buffer_.size() >= size + offset && offset >= 0);
buffer_.resize(size);
if (auto data = static_cast<const uint8_t*>(src))
{
memcpy(buffer_.data() + offset, src, size);
}
}
Texture::Texture(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
}
Texture::~Texture()
{
if (onDisposed_)
{
onDisposed_();
}
else
{
if (buffer_ > 0)
{
glDeleteTextures(1, &buffer_);
buffer_ = 0;
}
}
ES_SAFE_RELEASE(graphicsDevice_);
}
bool Texture::InitInternal(const Effekseer::Backend::TextureParameter& param)
{
if (graphicsDevice_->GetDeviceType() == OpenGLDeviceType::OpenGL2 || graphicsDevice_->GetDeviceType() == OpenGLDeviceType::OpenGLES2)
{
if ((param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM ||
param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM_SRGB))
{
// not supported
return false;
}
}
GLint bound = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound);
glGenTextures(1, &buffer_);
glBindTexture(GL_TEXTURE_2D, buffer_);
// Compressed texture
auto isCompressed = param.Format == Effekseer::Backend::TextureFormatType::BC1 ||
param.Format == Effekseer::Backend::TextureFormatType::BC2 ||
param.Format == Effekseer::Backend::TextureFormatType::BC3 ||
param.Format == Effekseer::Backend::TextureFormatType::BC1_SRGB ||
param.Format == Effekseer::Backend::TextureFormatType::BC2_SRGB ||
param.Format == Effekseer::Backend::TextureFormatType::BC3_SRGB;
const size_t initialDataSize = param.InitialData.size();
const void* initialDataPtr = param.InitialData.size() > 0 ? param.InitialData.data() : nullptr;
if (isCompressed)
{
GLenum format = GL_RGBA;
if (param.Format == Effekseer::Backend::TextureFormatType::BC1)
{
format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC2)
{
format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC3)
{
format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC1_SRGB)
{
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC2_SRGB)
{
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::BC3_SRGB)
{
format = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
}
GLExt::glCompressedTexImage2D(GL_TEXTURE_2D,
0,
format,
param.Size[0],
param.Size[1],
0,
static_cast<GLsizei>(initialDataSize),
initialDataPtr);
}
else
{
GLuint internalFormat = GL_RGBA;
GLenum format = GL_RGBA;
GLenum type = GL_UNSIGNED_BYTE;
if (param.Format == Effekseer::Backend::TextureFormatType::R8G8B8A8_UNORM)
{
internalFormat = GL_RGBA;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM)
{
internalFormat = GL_RGBA;
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R8G8B8A8_UNORM_SRGB)
{
internalFormat = GL_SRGB8_ALPHA8;
format = GL_RGBA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::B8G8R8A8_UNORM_SRGB)
{
internalFormat = GL_SRGB8_ALPHA8;
format = GL_BGRA;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R8_UNORM)
{
internalFormat = GL_R8;
format = GL_RED;
type = GL_UNSIGNED_BYTE;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R16G16_FLOAT)
{
internalFormat = GL_RG16F;
format = GL_RG;
type = GL_HALF_FLOAT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R16G16B16A16_FLOAT)
{
internalFormat = GL_RGBA16F;
format = GL_RGBA;
type = GL_HALF_FLOAT;
}
else if (param.Format == Effekseer::Backend::TextureFormatType::R32G32B32A32_FLOAT)
{
internalFormat = GL_RGBA32F;
format = GL_RGBA;
type = GL_FLOAT;
}
glTexImage2D(GL_TEXTURE_2D,
0,
internalFormat,
param.Size[0],
param.Size[1],
0,
format,
type,
initialDataPtr);
}
if (param.GenerateMipmap)
{
GLExt::glGenerateMipmap(GL_TEXTURE_2D);
}
glBindTexture(GL_TEXTURE_2D, bound);
size_ = param.Size;
format_ = param.Format;
hasMipmap_ = param.GenerateMipmap;
return true;
}
bool Texture::Init(const Effekseer::Backend::TextureParameter& param)
{
auto ret = InitInternal(param);
type_ = Effekseer::Backend::TextureType::Color2D;
return ret;
}
bool Texture::Init(const Effekseer::Backend::RenderTextureParameter& param)
{
Effekseer::Backend::TextureParameter paramInternal;
paramInternal.Size = param.Size;
paramInternal.Format = param.Format;
paramInternal.GenerateMipmap = false;
auto ret = Init(paramInternal);
type_ = Effekseer::Backend::TextureType::Render;
return ret;
}
bool Texture::Init(const Effekseer::Backend::DepthTextureParameter& param)
{
GLint bound = 0;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound);
glGenTextures(1, &buffer_);
glBindTexture(GL_TEXTURE_2D, buffer_);
if (param.Format == Effekseer::Backend::TextureFormatType::D24S8)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, param.Size[0], param.Size[1], 0, GL_DEPTH_STENCIL, GL_FLOAT, nullptr);
}
else if (param.Format == Effekseer::Backend::TextureFormatType::D32S8)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH32F_STENCIL8, param.Size[0], param.Size[1], 0, GL_DEPTH_STENCIL, GL_FLOAT, nullptr);
}
else if (param.Format == Effekseer::Backend::TextureFormatType::D32S8)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, param.Size[0], param.Size[1], 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
}
else
{
glDeleteTextures(1, &buffer_);
buffer_ = 0;
glBindTexture(GL_TEXTURE_2D, bound);
return false;
}
glBindTexture(GL_TEXTURE_2D, bound);
size_ = param.Size;
format_ = param.Format;
hasMipmap_ = false;
type_ = Effekseer::Backend::TextureType::Depth;
return true;
}
bool Texture::Init(GLuint buffer, const std::function<void()>& onDisposed)
{
if (buffer == 0)
return false;
buffer_ = buffer;
onDisposed_ = onDisposed;
hasMipmap_ = false;
type_ = Effekseer::Backend::TextureType::Color2D;
return true;
}
bool VertexLayout::Init(const Effekseer::Backend::VertexLayoutElement* elements, int32_t elementCount)
{
elements_.resize(elementCount);
for (int32_t i = 0; i < elementCount; i++)
{
elements_[i] = elements[i];
}
return true;
}
Shader::Shader(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
}
Shader::~Shader()
{
if (program_ > 0)
{
GLExt::glDeleteProgram(program_);
}
if (vao_ > 0)
{
GLExt::glDeleteVertexArrays(1, &vao_);
}
ES_SAFE_RELEASE(graphicsDevice_);
}
bool Shader::Init(const char* vsCode, const char* psCode, Effekseer::Backend::UniformLayoutRef& layout)
{
GLint vsCodeLen = static_cast<GLint>(strlen(vsCode));
GLint psCodeLen = static_cast<GLint>(strlen(psCode));
GLint res_vs, res_fs, res_link = 0;
auto vert_shader = GLExt::glCreateShader(GL_VERTEX_SHADER);
GLExt::glShaderSource(vert_shader, 1, &vsCode, &vsCodeLen);
GLExt::glCompileShader(vert_shader);
GLExt::glGetShaderiv(vert_shader, GL_COMPILE_STATUS, &res_vs);
auto frag_shader = GLExt::glCreateShader(GL_FRAGMENT_SHADER);
GLExt::glShaderSource(frag_shader, 1, &psCode, &psCodeLen);
GLExt::glCompileShader(frag_shader);
GLExt::glGetShaderiv(frag_shader, GL_COMPILE_STATUS, &res_fs);
// create shader program
auto program = GLExt::glCreateProgram();
GLExt::glAttachShader(program, vert_shader);
GLExt::glAttachShader(program, frag_shader);
// link shaders
GLExt::glLinkProgram(program);
GLExt::glGetProgramiv(program, GL_LINK_STATUS, &res_link);
#ifndef NDEBUG
if (res_link == GL_FALSE)
{
// output errors
char log[512];
int32_t log_size;
GLExt::glGetShaderInfoLog(vert_shader, sizeof(log), &log_size, log);
if (log_size > 0)
{
LOG(": Vertex Shader error.\n");
LOG(log);
}
GLExt::glGetShaderInfoLog(frag_shader, sizeof(log), &log_size, log);
if (log_size > 0)
{
LOG(": Fragment Shader error.\n");
LOG(log);
}
GLExt::glGetProgramInfoLog(program, sizeof(log), &log_size, log);
if (log_size > 0)
{
LOG(": Shader Link error.\n");
LOG(log);
}
}
#endif
// dispose shader objects
GLExt::glDeleteShader(frag_shader);
GLExt::glDeleteShader(vert_shader);
if (res_link == GL_FALSE)
{
GLExt::glDeleteProgram(program);
return false;
}
program_ = program;
if (GLExt::IsSupportedVertexArray())
{
GLExt::glGenVertexArrays(1, &vao_);
}
layout_ = layout;
return true;
}
bool PipelineState::Init(const Effekseer::Backend::PipelineStateParameter& param)
{
param_ = param;
return true;
}
RenderPass::RenderPass(GraphicsDevice* graphicsDevice)
: graphicsDevice_(graphicsDevice)
{
ES_SAFE_ADDREF(graphicsDevice_);
}
RenderPass::~RenderPass()
{
if (buffer_ > 0)
{
GLExt::glDeleteFramebuffers(1, &buffer_);
buffer_ = 0;
}
ES_SAFE_RELEASE(graphicsDevice_);
}
bool RenderPass::Init(Effekseer::FixedSizeVector<Effekseer::Backend::TextureRef, Effekseer::Backend::RenderTargetMax>& textures, Effekseer::Backend::TextureRef depthTexture)
{
for (int32_t i = 0; i < textures.size(); i++)
{
if (textures.at(i) == nullptr)
{
Effekseer::Log(Effekseer::LogType::Error, "RenderPass : textures " + std::to_string(i) + " must not be null.");
return false;
}
if (textures.at(i)->GetTextureType() != Effekseer::Backend::TextureType::Render)
{
Effekseer::Log(Effekseer::LogType::Error, "RenderPass : textures " + std::to_string(i) + " must be Render.");
return false;
}
}
if (depthTexture != nullptr && depthTexture->GetTextureType() != Effekseer::Backend::TextureType::Depth)
{
Effekseer::Log(Effekseer::LogType::Error, "RenderPass : depthTexture must be Depth.");
return false;
}
textures_ = textures;
depthTexture_ = depthTexture;
GLExt::glGenFramebuffers(1, &buffer_);
if (buffer_ == 0)
{
return false;
}
GLint backupFramebuffer;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &backupFramebuffer);
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, buffer_);
for (int32_t i = 0; i < textures.size(); i++)
{
GLExt::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D, static_cast<Texture*>(textures.at(i).Get())->GetBuffer(), 0);
}
if (depthTexture != nullptr)
{
GLExt::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, static_cast<Texture*>(depthTexture.Get())->GetBuffer(), 0);
}
textures_ = textures;
depthTexture_ = depthTexture;
const GLenum bufs[] = {
GL_COLOR_ATTACHMENT0,
GL_COLOR_ATTACHMENT1,
GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3,
};
GLExt::glDrawBuffers(textures.size(), bufs);
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, backupFramebuffer);
return true;
}
GraphicsDevice::GraphicsDevice(OpenGLDeviceType deviceType)
: deviceType_(deviceType)
{
GLExt::Initialize(deviceType);
if (deviceType == OpenGLDeviceType::OpenGL3 || deviceType == OpenGLDeviceType::OpenGLES3)
{
GLExt::glGenSamplers(Effekseer::TextureSlotMax, samplers_.data());
}
}
GraphicsDevice::~GraphicsDevice()
{
if (deviceType_ == OpenGLDeviceType::OpenGL3 || deviceType_ == OpenGLDeviceType::OpenGLES3)
{
GLExt::glDeleteSamplers(Effekseer::TextureSlotMax, samplers_.data());
}
}
void GraphicsDevice::LostDevice()
{
for (auto& o : objects_)
{
o->OnLostDevice();
}
}
void GraphicsDevice::ResetDevice()
{
for (auto& o : objects_)
{
o->OnResetDevice();
}
}
OpenGLDeviceType GraphicsDevice::GetDeviceType() const
{
return deviceType_;
}
void GraphicsDevice::Register(DeviceObject* deviceObject)
{
objects_.insert(deviceObject);
}
void GraphicsDevice::Unregister(DeviceObject* deviceObject)
{
objects_.erase(deviceObject);
}
Effekseer::Backend::VertexBufferRef GraphicsDevice::CreateVertexBuffer(int32_t size, const void* initialData, bool isDynamic)
{
auto ret = Effekseer::MakeRefPtr<VertexBuffer>(this);
if (!ret->Init(size, isDynamic))
{
return nullptr;
}
ret->UpdateData(initialData, size, 0);
return ret;
}
Effekseer::Backend::IndexBufferRef GraphicsDevice::CreateIndexBuffer(int32_t elementCount, const void* initialData, Effekseer::Backend::IndexBufferStrideType stride)
{
auto ret = Effekseer::MakeRefPtr<IndexBuffer>(this);
if (!ret->Init(elementCount, stride == Effekseer::Backend::IndexBufferStrideType::Stride4 ? 4 : 2))
{
return nullptr;
}
ret->UpdateData(initialData, elementCount * (stride == Effekseer::Backend::IndexBufferStrideType::Stride4 ? 4 : 2), 0);
return ret;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateTexture(const Effekseer::Backend::TextureParameter& param)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateRenderTexture(const Effekseer::Backend::RenderTextureParameter& param)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateDepthTexture(const Effekseer::Backend::DepthTextureParameter& param)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::UniformBufferRef GraphicsDevice::CreateUniformBuffer(int32_t size, const void* initialData)
{
auto ret = Effekseer::MakeRefPtr<UniformBuffer>();
if (!ret->Init(size, initialData))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::VertexLayoutRef GraphicsDevice::CreateVertexLayout(const Effekseer::Backend::VertexLayoutElement* elements, int32_t elementCount)
{
auto ret = Effekseer::MakeRefPtr<VertexLayout>();
if (!ret->Init(elements, elementCount))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::RenderPassRef GraphicsDevice::CreateRenderPass(Effekseer::FixedSizeVector<Effekseer::Backend::TextureRef, Effekseer::Backend::RenderTargetMax>& textures, Effekseer::Backend::TextureRef& depthTexture)
{
auto ret = Effekseer::MakeRefPtr<RenderPass>(this);
if (!ret->Init(textures, depthTexture))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::PipelineStateRef GraphicsDevice::CreatePipelineState(const Effekseer::Backend::PipelineStateParameter& param)
{
auto ret = Effekseer::MakeRefPtr<PipelineState>();
if (!ret->Init(param))
{
return nullptr;
}
return ret;
}
Effekseer::Backend::ShaderRef GraphicsDevice::CreateShaderFromKey(const char* key)
{
return nullptr;
}
Effekseer::Backend::ShaderRef GraphicsDevice::CreateShaderFromCodes(const char* vsCode, const char* psCode, Effekseer::Backend::UniformLayoutRef layout)
{
auto ret = Effekseer::MakeRefPtr<Shader>(this);
if (!ret->Init(vsCode, psCode, layout))
{
return nullptr;
}
return ret;
}
void GraphicsDevice::Draw(const Effekseer::Backend::DrawParameter& drawParam)
{
if (drawParam.VertexBufferPtr == nullptr ||
drawParam.IndexBufferPtr == nullptr ||
drawParam.PipelineStatePtr == nullptr)
{
return;
}
auto pip = static_cast<PipelineState*>(drawParam.PipelineStatePtr.Get());
auto shader = static_cast<Shader*>(pip->GetParam().ShaderPtr.Get());
auto vertexLayout = static_cast<VertexLayout*>(pip->GetParam().VertexLayoutPtr.Get());
if (shader->GetLayout() == nullptr)
{
return;
}
GLint currentVAO = 0;
if (GLExt::IsSupportedVertexArray())
{
glGetIntegerv(GL_VERTEX_ARRAY_BINDING, ¤tVAO);
GLExt::glBindVertexArray(shader->GetVAO());
}
GLExt::glBindBuffer(GL_ARRAY_BUFFER, static_cast<VertexBuffer*>(drawParam.VertexBufferPtr.Get())->GetBuffer());
GLExt::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, static_cast<IndexBuffer*>(drawParam.IndexBufferPtr.Get())->GetBuffer());
GLExt::glUseProgram(shader->GetProgram());
// textures
auto textureCount = std::min(static_cast<int32_t>(shader->GetLayout()->GetTextures().size()), drawParam.TextureCount);
for (int32_t i = 0; i < textureCount; i++)
{
auto textureSlot = GLExt::glGetUniformLocation(shader->GetProgram(), shader->GetLayout()->GetTextures()[i].c_str());
if (textureSlot < 0)
{
continue;
}
GLExt::glUniform1i(textureSlot, i);
auto texture = static_cast<Texture*>(drawParam.TexturePtrs[i].Get());
if (texture != nullptr)
{
GLExt::glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, texture->GetBuffer());
static const GLint glfilterMin[] = {GL_NEAREST, GL_LINEAR_MIPMAP_LINEAR};
static const GLint glfilterMin_NoneMipmap[] = {GL_NEAREST, GL_LINEAR};
static const GLint glfilterMag[] = {GL_NEAREST, GL_LINEAR};
static const GLint glwrap[] = {GL_REPEAT, GL_CLAMP_TO_EDGE};
GLint filterMin = 0;
GLint filterMag = 0;
GLint wrap = 0;
if (drawParam.TextureSamplingTypes[i] == Effekseer::Backend::TextureSamplingType::Linear)
{
if (texture->GetHasMipmap())
{
filterMin = glfilterMin[1];
}
else
{
filterMin = glfilterMin_NoneMipmap[1];
}
filterMag = glfilterMag[1];
}
else
{
if (texture->GetHasMipmap())
{
filterMin = glfilterMin[0];
}
else
{
filterMin = glfilterMin_NoneMipmap[0];
}
filterMag = glfilterMag[0];
}
if (drawParam.TextureWrapTypes[i] == Effekseer::Backend::TextureWrapType::Clamp)
{
wrap = glwrap[1];
}
else
{
wrap = glwrap[0];
}
if (deviceType_ == OpenGLDeviceType::OpenGL3 || deviceType_ == OpenGLDeviceType::OpenGLES3)
{
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_MAG_FILTER, filterMag);
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_MIN_FILTER, filterMin);
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_WRAP_S, wrap);
GLExt::glSamplerParameteri(samplers_[i], GL_TEXTURE_WRAP_T, wrap);
GLExt::glBindSampler(i, samplers_[i]);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filterMag);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filterMin);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap);
}
}
}
// uniformss
for (size_t i = 0; i < shader->GetLayout()->GetElements().size(); i++)
{
const auto& element = shader->GetLayout()->GetElements()[i];
auto loc = GLExt::glGetUniformLocation(shader->GetProgram(), element.Name.c_str());
if (loc < 0)
{
continue;
}
UniformBuffer* uniformBuffer = nullptr;
if (element.Stage == Effekseer::Backend::ShaderStageType::Vertex)
{
uniformBuffer = static_cast<UniformBuffer*>(drawParam.VertexUniformBufferPtr.Get());
}
else if (element.Stage == Effekseer::Backend::ShaderStageType::Pixel)
{
uniformBuffer = static_cast<UniformBuffer*>(drawParam.PixelUniformBufferPtr.Get());
}
if (uniformBuffer != nullptr)
{
if (element.Type == Effekseer::Backend::UniformBufferLayoutElementType::Vector4)
{
const auto& buffer = uniformBuffer->GetBuffer();
assert(buffer.size() >= element.Offset + sizeof(float) * 4);
GLExt::glUniform4fv(loc, 1, reinterpret_cast<const GLfloat*>(buffer.data() + element.Offset));
}
else if (element.Type == Effekseer::Backend::UniformBufferLayoutElementType::Matrix44)
{
const auto& buffer = uniformBuffer->GetBuffer();
assert(buffer.size() >= element.Offset + sizeof(float) * 4 * 4);
GLExt::glUniformMatrix4fv(loc, 1, GL_FALSE, reinterpret_cast<const GLfloat*>(buffer.data() + element.Offset));
}
else
{
// Unimplemented
assert(0);
}
}
else
{
// Invalid
assert(0);
}
}
GLCheckError();
// layouts
{
int32_t vertexSize = 0;
for (size_t i = 0; i < vertexLayout->GetElements().size(); i++)
{
const auto& element = vertexLayout->GetElements()[i];
vertexSize += Effekseer::Backend::GetVertexLayoutFormatSize(element.Format);
}
uint16_t offset = 0;
for (size_t i = 0; i < vertexLayout->GetElements().size(); i++)
{
const auto& element = vertexLayout->GetElements()[i];
auto loc = GLExt::glGetAttribLocation(shader->GetProgram(), element.Name.c_str());
GLenum type = {};
int32_t count = {};
GLboolean isNormalized = false;
if (element.Format == Effekseer::Backend::VertexLayoutFormat::R8G8B8A8_UINT)
{
count = 4;
type = GL_UNSIGNED_BYTE;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R8G8B8A8_UNORM)
{
count = 4;
type = GL_UNSIGNED_BYTE;
isNormalized = GL_TRUE;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32_FLOAT)
{
count = 1;
type = GL_FLOAT;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32G32_FLOAT)
{
count = 2;
type = GL_FLOAT;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32G32B32_FLOAT)
{
count = 3;
type = GL_FLOAT;
}
else if (element.Format == Effekseer::Backend::VertexLayoutFormat::R32G32B32A32_FLOAT)
{
count = 4;
type = GL_FLOAT;
}
else
{
assert(0);
}
if (loc >= 0)
{
GLExt::glEnableVertexAttribArray(loc);
GLExt::glVertexAttribPointer(loc,
count,
type,
isNormalized,
vertexSize,
reinterpret_cast<GLvoid*>(offset));
}
offset += Effekseer::Backend::GetVertexLayoutFormatSize(element.Format);
}
}
GLCheckError();
// States
GLint frontFace = 0;
glGetIntegerv(GL_FRONT_FACE, &frontFace);
if (GL_CW == frontFace)
{
if (pip->GetParam().Culling == Effekseer::Backend::CullingType::Clockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::CounterClockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::DoubleSide)
{
glDisable(GL_CULL_FACE);
glCullFace(GL_FRONT_AND_BACK);
}
}
else
{
if (pip->GetParam().Culling == Effekseer::Backend::CullingType::Clockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::CounterClockwise)
{
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
}
else if (pip->GetParam().Culling == Effekseer::Backend::CullingType::DoubleSide)
{
glDisable(GL_CULL_FACE);
glCullFace(GL_FRONT_AND_BACK);
}
}
GLCheckError();
{
if (pip->GetParam().IsDepthTestEnabled || pip->GetParam().IsDepthWriteEnabled)
{
glEnable(GL_DEPTH_TEST);
}
else
{
glDisable(GL_DEPTH_TEST);
}
if (pip->GetParam().IsDepthTestEnabled)
{
std::array<GLenum, 8> depthFuncs;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Less)] = GL_LESS;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::LessEqual)] = GL_LEQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::NotEqual)] = GL_NOTEQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Equal)] = GL_EQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Greater)] = GL_GREATER;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::GreaterEqual)] = GL_GEQUAL;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Never)] = GL_NEVER;
depthFuncs[static_cast<int>(::Effekseer::Backend::DepthFuncType::Always)] = GL_ALWAYS;
glDepthFunc(depthFuncs[static_cast<int>(pip->GetParam().DepthFunc)]);
}
else
{
glDepthFunc(GL_ALWAYS);
}
glDepthMask(pip->GetParam().IsDepthWriteEnabled);
}
{
if (pip->GetParam().IsBlendEnabled)
{
glEnable(GL_BLEND);
std::array<GLenum, 5> blendEq;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Add)] = GL_FUNC_ADD;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Sub)] = GL_FUNC_SUBTRACT;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::ReverseSub)] = GL_FUNC_REVERSE_SUBTRACT;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Min)] = GL_MIN;
blendEq[static_cast<int>(::Effekseer::Backend::BlendEquationType::Max)] = GL_MAX;
std::array<GLenum, 10> blendFunc;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::Zero)] = GL_ZERO;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::One)] = GL_ONE;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::SrcColor)] = GL_SRC_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusSrcColor)] = GL_ONE_MINUS_SRC_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::SrcAlpha)] = GL_SRC_ALPHA;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusSrcAlpha)] = GL_ONE_MINUS_SRC_ALPHA;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::DstColor)] = GL_DST_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusDstColor)] = GL_ONE_MINUS_DST_COLOR;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::DstAlpha)] = GL_DST_ALPHA;
blendFunc[static_cast<int>(::Effekseer::Backend::BlendFuncType::OneMinusDstAlpha)] = GL_ONE_MINUS_DST_ALPHA;
GLExt::glBlendEquationSeparate(blendEq[static_cast<int>(pip->GetParam().BlendEquationRGB)], blendEq[static_cast<int>(pip->GetParam().BlendEquationAlpha)]);
GLExt::glBlendFuncSeparate(blendFunc[static_cast<int>(pip->GetParam().BlendSrcFunc)], blendFunc[static_cast<int>(pip->GetParam().BlendDstFunc)], blendFunc[static_cast<int>(pip->GetParam().BlendSrcFuncAlpha)], blendFunc[static_cast<int>(pip->GetParam().BlendDstFuncAlpha)]);
}
else
{
glDisable(GL_BLEND);
}
}
GLCheckError();
GLenum primitiveMode = {};
GLenum indexStrideType = {};
int32_t indexPerPrimitive = {};
if (pip->GetParam().Topology == Effekseer::Backend::TopologyType::Triangle)
{
primitiveMode = GL_TRIANGLES;
indexPerPrimitive = 3;
}
else if (pip->GetParam().Topology == Effekseer::Backend::TopologyType::Line)
{
primitiveMode = GL_LINES;
indexPerPrimitive = 2;
}
else if (pip->GetParam().Topology == Effekseer::Backend::TopologyType::Point)
{
primitiveMode = GL_POINTS;
indexPerPrimitive = 1;
}
if (drawParam.IndexBufferPtr->GetStrideType() == Effekseer::Backend::IndexBufferStrideType::Stride4)
{
indexStrideType = GL_UNSIGNED_INT;
}
else if (drawParam.IndexBufferPtr->GetStrideType() == Effekseer::Backend::IndexBufferStrideType::Stride2)
{
indexStrideType = GL_UNSIGNED_SHORT;
}
if (drawParam.InstanceCount > 1)
{
GLExt::glDrawElementsInstanced(primitiveMode, indexPerPrimitive * drawParam.PrimitiveCount, indexStrideType, nullptr, drawParam.PrimitiveCount);
}
else
{
glDrawElements(primitiveMode, indexPerPrimitive * drawParam.PrimitiveCount, indexStrideType, nullptr);
}
for (size_t i = 0; i < vertexLayout->GetElements().size(); i++)
{
const auto& element = vertexLayout->GetElements()[i];
auto loc = GLExt::glGetAttribLocation(shader->GetProgram(), element.Name.c_str());
if (loc >= 0)
{
GLExt::glDisableVertexAttribArray(loc);
}
}
if (GLExt::IsSupportedVertexArray())
{
GLExt::glBindVertexArray(currentVAO);
}
GLCheckError();
}
void GraphicsDevice::BeginRenderPass(Effekseer::Backend::RenderPassRef& renderPass, bool isColorCleared, bool isDepthCleared, Effekseer::Color clearColor)
{
if (renderPass != nullptr)
{
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, static_cast<RenderPass*>(renderPass.Get())->GetBuffer());
}
else
{
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLExt::glDrawBuffer(GL_BACK);
}
GLbitfield flag = 0;
if (isColorCleared)
{
flag |= GL_COLOR_BUFFER_BIT;
glClearColor(clearColor.R / 255.0f, clearColor.G / 255.0f, clearColor.B / 255.0f, clearColor.A / 255.0f);
GLCheckError();
}
if (isDepthCleared)
{
flag |= GL_DEPTH_BUFFER_BIT;
}
if (flag != 0)
{
glClear(flag);
}
GLCheckError();
}
void GraphicsDevice::EndRenderPass()
{
GLExt::glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLCheckError();
}
bool GraphicsDevice::UpdateUniformBuffer(Effekseer::Backend::UniformBufferRef& buffer, int32_t size, int32_t offset, const void* data)
{
if (buffer == nullptr)
{
return false;
}
auto b = static_cast<UniformBuffer*>(buffer.Get());
b->UpdateData(data, size, offset);
return true;
}
Effekseer::Backend::TextureRef GraphicsDevice::CreateTexture(GLuint buffer, const std::function<void()>& onDisposed)
{
auto ret = Effekseer::MakeRefPtr<Texture>(this);
if (!ret->Init(buffer, onDisposed))
{
return nullptr;
}
return ret;
}
} // namespace Backend
} // namespace EffekseerRendererGL |
// @(#)root/treeviewer:$Id$
//Author : Andrei Gheata 16/08/00
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
//////////////////////////////////////////////////////////////////////////
//
// TreeViewer is a graphic user interface designed to handle ROOT trees and to
// take advantage of TTree class features.
//
// It uses ROOT native GUI widgets adapted for 'drag and drop' functionality.
// in the same session.
// The following capabilities are making the viewer a helpful tool for analysis:
// - several trees may be opened in the same session;
// - branches and leaves can be easily browsed or scanned;
// - fast drawing of branch expressions by double-clicking;
// - new variables/selections easy to compose with the built-in editor;
// - histograms can be composed by dragging leaves or user-defined expressions
// to X, Y and Z axis items;
// - the tree entries to be processed can be selected with a double slider;
// - selections can be defined and activated by dragging them to the 'Cut' item;
// - all expressions can be aliased and aliases can be used in composing others;
// - input/output event lists easy to handle;
// - menu with histogram drawing options;
// - user commands may be executed within the viewer and the current command
// can be echoed;
// - current 'Draw' event loop is reflected by a progress bar and may be
// interrupted by the user;
// - all widgets have self-explaining tool tips and/or context menus;
// - expressions/leaves can be dragged to a 'scan box' and scanned by
// double-clicking this item. The result can be redirected to an ASCII file;
//
// The layout has the following items:
//
// - a menu bar with entries : File, Edit, Run, Options and Help;
// - a toolbar in the upper part where you can issue user commands, change
// the drawing option and the histogram name, three check buttons Hist, Rec
// and Scan.HIST toggles histogram drawing mode, REC enables recording of the
// last command issued and SCAN enables redirecting of TTree::Scan command in
// an ASCII file (see -Scanning expressions-);
// - a button bar in the lower part with : buttons DRAW/STOP that issue histogram
// drawing and stop the current command respectively, two text widgets where
// input and output event lists can be specified, a message box and a RESET
// button on the right that clear edited expression content (see Editing...)
// - a tree-type list on the main left panel where you can select among trees or
// branches. The tree/branch will be detailed in the right panel.
// Mapped trees are provided with context menus, activated by right-clicking;
// - a view-type list on the right panel. The first column contain X, Y and
// Z expression items, an optional cut and ten optional editable expressions.
// Expressions and leaf-type items can be dragged or deleted. A right click on
// the list-box or item activates context menus.
//
// Opening a new tree and saving a session :
//
// To open a new tree in the viewer use <File/Open tree file> menu
// The content of the file (keys) will be listed. Use <SetTreeName> function
// from the context menu of the right panel, entering a tree name among those
// listed.
// To save the current session, use <File/Save> menu or the <SaveSource>
// function from the context menu of the right panel (to specify the name of the
// file - name.C)
// To open a previously saved session for the tree MyTree, first open MyTree
// in the browser, then use <File/Open session> menu.
//
// Dragging items:
//
// Items that can be dragged from the list in the right : expressions and
// leaves. Dragging an item and dropping to another will copy the content of first
// to the last (leaf->expression, expression->expression). Items far to the right
// side of the list can be easily dragged to the left (where expressions are
// placed) by dragging them to the left at least 10 pixels.
//
// Editing expressions
//
// Any editable expression from the right panel has two components : a
// true name (that will be used when TTree::Draw() commands are issued) and an
// alias. The visible name is the alias. Aliases of user defined expressions have
// a leading ~ and may be used in new expressions. Expressions containing boolean
// operators have a specific icon and may be dragged to the active cut (scissors
// item) position.
// The expression editor can be activated by double-clicking empty expression,
// using <EditExpression> from the selected expression context menu or using
// <Edit/Expression> menu.
// The editor will pop-up in the left part, but it can be moved.
// The editor usage is the following :
// - you can write C expressions made of leaf names by hand or you can insert
// any item from the right panel by clicking on it (recommandable);
// - you can click on other expressions/leaves to paste them in the editor;
// - you should write the item alias by hand since it not only make the expression
// meaningfull, but it also highly improve the layout for big expressions
// - you may redefine an old alias - the other expressions depending on it will
// be modified accordingly. An alias must not be the leading string of other aliases.
// When Draw commands are issued, the name of the corresponding histogram axes
// will become the aliases of the expressions.
//
// User commands can be issued directly from the textbox labeled "Command"
// from the upper-left toolbar by typing and pressing Enter at the end.
// An other way is from the right panel context menu : ExecuteCommand.
// All commands can be interrupted at any time by pressing the STOP button
// from the bottom-left
// You can toggle recording of the current command in the history file by
// checking the Rec button from the top-right
//
// Context menus
//
// You can activate context menus by right-clicking on items or inside the
// right panel.
// Context menus for mapped items from the left tree-type list :
// The items from the left that are provided with context menus are tree and
// branch items. You can directly activate the *MENU* marked methods of TTree
// from this menu.
// Context menu for the right panel :
// A general context menu is acivated if the user right-clicks the right panel.
// Commands are :
// - EmptyAll : clears the content of all expressions;
// - ExecuteCommand : execute a ROOT command;
// - MakeSelector : equivalent of TTree::MakeSelector();
// - NewExpression : add an expression item in the right panel;
// - Process : equivalent of TTree::Process();
// - SaveSource : save the current session as a C++ macro;
// - SetScanFileName : define a name for the file where TTree::Scan command
// is redirected when the <Scan> button is checked;
// - SetTreeName : open a new tree whith this name in the viewer;
// A specific context menu is activated if expressions/leaves are right-clicked.
// Commands are :
// - Draw : draw a histogram for this item;
// - EditExpression : pops-up the expression editor;
// - Empty : empty the name and alias of this item;
// - RemoveItem : removes clicked item from the list;
// - Scan : scan this expression;
// - SetExpression : edit name and alias for this item by hand;
//
// Starting the viewer
//
// 1) From the TBrowser :
// Select a tree in the TBrowser, then call the StartViewer() method from its
// context menu (right-click on the tree).
// 2) From the command line :
// Start a ROOT session in the directory where you have your tree.
// You will need first to load the library for TTreeViewer and optionally other
// libraries for user defined classes (you can do this later in the session) :
// root [0] gSystem->Load(\"TTreeViewer\");
// Supposing you have the tree MyTree in the file MyFile, you can do :
// root [1] TFile file(\"Myfile\");
// root [2] new TTreeViewer(\"Mytree\");
// or :
// root [2] TreeViewer *tv = new TTreeViewer();
// root [3] tv->SetTreeName(\"Mytree\");
//
//Begin_Html
/*
<img src="treeview.gif">
*/
//End_Html
//
#include "RConfigure.h"
#include "snprintf.h"
#include "Riostream.h"
#include "TTreeViewer.h"
#include "HelpText.h"
#include "HelpTextTV.h"
#include "TTVLVContainer.h"
#include "TTVSession.h"
#include "TROOT.h"
#include "TError.h"
#include "TGMsgBox.h"
#include "TTreePlayer.h"
#include "TContextMenu.h"
#include "TInterpreter.h"
#include "TLeaf.h"
#include "TRootHelpDialog.h"
#include "TSystem.h"
#include "TApplication.h"
#include "TVirtualX.h"
#include "TGClient.h"
#include "TKey.h"
#include "TFile.h"
#include "TGMenu.h"
#include "TGFrame.h"
#include "TCanvas.h"
#include "TH1.h"
#include "TTree.h"
#include "TFriendElement.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TGButton.h"
#include "TGButtonGroup.h"
#include "TGTextEntry.h"
#include "TGComboBox.h"
#include "TGLabel.h"
#include "TGListView.h"
#include "TGListTree.h"
#include "TGMimeTypes.h"
#include "TGSplitter.h"
#include "TGDoubleSlider.h"
#include "TGToolBar.h"
#include "TGStatusBar.h"
#include "Getline.h"
#include "TTimer.h"
#include "TG3DLine.h"
#include "TGFileDialog.h"
#include "TGProgressBar.h"
#include "TClonesArray.h"
#include "TSpider.h"
#ifdef WIN32
#include "TWin32SplashThread.h"
#endif
// drawing options
static const char* gOptgen[16] =
{
"","AXIS","HIST","SAME","CYL","POL","SPH","PSR","LEGO","LEGO1","LEGO2",
"SURF","SURF1","SURF2","SURF3","SURF4"
};
static const char* gOpt1D[12] =
{
"","AH","B","C","E","E1","E2","E3","E4","L","P","*H"
};
static const char* gOpt2D[14] =
{
"","ARR","BOX","COL","COL2","CONT","CONT0","CONT1","CONT2","CONT3",
"FB","BB","SCAT","PROF"
};
static const char* gOpenTypes[] = {"Root files", "*.root",
0, 0 };
static const char* gMacroTypes[] = {"C++ macros", "*.C",
0, 0 };
// Menu command id's
enum ERootTreeViewerCommands {
kFileCanvas,
kFileBrowse,
kFileLoadLibrary = 3,
kFileOpenSession,
kFileSaveMacro,
kFilePrint,
kFileClose,
kFileQuit,
kEditExpression,
kEditCut,
kEditMacro,
kEditEvent,
kRunCommand,
kRunMacro,
kOptionsReset,
kOptionsGeneral = 20,
kOptions1D = 50,
kOptions2D = 70,
kHelpAbout = 100,
kHelpAboutTV,
kHelpStart,
kHelpLayout,
kHelpOpenSave,
kHelpDragging,
kHelpEditing,
kHelpSession,
kHelpCommands,
kHelpContext,
kHelpDrawing,
kHelpMacros,
kBarCommand,
kBarOption,
kBarCut,
kAxis
};
// button Id's
enum EButtonIdentifiers {
kDRAW,
kRESET,
kSTOP,
kCLOSE,
kSLIDER,
kBGFirst,
kBGPrevious,
kBGRecord,
kBGNext,
kBGLast
};
ClassImp(TTreeViewer)
//______________________________________________________________________________
TTreeViewer::TTreeViewer(const char* treeName) :
TGMainFrame(0,10,10,kVerticalFrame),
fDimension(0), fVarDraw(0), fScanMode(0),
fTreeIndex(0), fDefaultCursor(0), fWatchCursor(0),
fCounting(0), fStopMapping(0), fEnableCut(0),fNexpressions(0)
{
// TTreeViewer default constructor
fTree = 0;
if (!gClient) return;
char command[128];
sprintf(command, "TTreeViewer *gTV = (TTreeViewer*)0x%lx", (ULong_t)this);
gROOT->ProcessLine(command);
gROOT->ProcessLine("TTree *tv__tree = 0;");
fTreeList = new TList;
gROOT->ProcessLine("TList *tv__tree_list = new TList;");
fFilename = "";
gROOT->ProcessLine("TFile *tv__tree_file = 0;");
gInterpreter->SaveContext();
BuildInterface();
SetTreeName(treeName);
}
//______________________________________________________________________________
TTreeViewer::TTreeViewer(const TTree *tree) :
TGMainFrame(0, 10, 10, kVerticalFrame),
fDimension(0), fVarDraw(0), fScanMode(0),
fTreeIndex(0), fDefaultCursor(0), fWatchCursor(0),
fCounting(0), fStopMapping(0), fEnableCut(0),fNexpressions(0)
{
// TTreeViewer constructor with a pointer to a Tree
fTree = 0;
char command[128];
sprintf(command, "TTreeViewer *gTV = (TTreeViewer*)0x%lx", (ULong_t)this);
gROOT->ProcessLine(command);
if (!tree) return;
gROOT->ProcessLine("TTree *tv__tree = 0;");
fTreeList = new TList;
gROOT->ProcessLine("TList *tv__tree_list = new TList;");
fFilename = "";
gROOT->ProcessLine("TFile *tv__tree_file = 0;");
gInterpreter->SaveContext();
BuildInterface();
TDirectory *dirsav = gDirectory;
TDirectory *cdir = tree->GetDirectory();
if (cdir) cdir->cd();
SetTreeName(tree->GetName());
// If the tree is a chain, the tree directory will be changed by SwitchTree
// (called by SetTreeName)
cdir = tree->GetDirectory();
if (cdir) {
if (cdir->GetFile()) fFilename = cdir->GetFile()->GetName();
}
if (dirsav) dirsav->cd();
}
//______________________________________________________________________________
void TTreeViewer::AppendTree(TTree *tree)
{
// Allow geting the tree from the context menu.
if (!tree) return;
TTree *ftree;
if (fTreeList) {
if (fTreeList->FindObject(tree)) {
printf("Tree found\n");
TIter next(fTreeList);
Int_t index = 0;
while ((ftree = (TTree*)next())) {
if (ftree==tree) {printf("found at index %i\n", index);break;}
index++;
}
SwitchTree(index);
if (fTree != fMappedTree) {
// switch also the global "tree" variable
fLVContainer->RemoveNonStatic();
// map it on the right panel
MapTree(fTree);
fListView->Layout();
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
TGListTreeItem *item = fLt->FindChildByName(parent, fTree->GetName());
fLt->ClearHighlighted();
fLt->HighlightItem(item);
fClient->NeedRedraw(fLt);
}
return;
}
}
if (fTree != tree) {
fTree = tree;
// load the tree via the interpreter
char command[100];
command[0] = 0;
// define a global "tree" variable for the same tree
sprintf(command, "tv__tree = (TTree *)0x%lx;", (ULong_t)tree);
ExecuteCommand(command);
}
//--- add the tree to the list if it is not already in
if (fTreeList) fTreeList->Add(fTree);
ExecuteCommand("tv__tree_list->Add(tv__tree);");
//--- map this tree
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
if (!parent) parent = fLt->AddItem(base, "TreeList", new ULong_t(kLTNoType));
ULong_t *itemType = new ULong_t((fTreeIndex << 8) | kLTTreeType);
fTreeIndex++;
TGListTreeItem *lTreeItem = fLt->AddItem(parent, tree->GetName(), itemType,
gClient->GetPicture("tree_t.xpm"), gClient->GetPicture("tree_t.xpm"));
MapTree(fTree, lTreeItem, kFALSE);
fLt->OpenItem(parent);
fLt->HighlightItem(lTreeItem);
fClient->NeedRedraw(fLt);
//--- map slider and list view
SwitchTree(fTreeIndex-1);
fLVContainer->RemoveNonStatic();
MapTree(fTree);
fListView->Layout();
SetFile();
}
//______________________________________________________________________________
void TTreeViewer::SetNexpressions(Int_t expr)
{
// Change the number of expression widgets.
Int_t diff = expr - fNexpressions;
if (diff <= 0) return;
if (!fLVContainer) return;
for (Int_t i=0; i<TMath::Abs(diff); i++) NewExpression();
}
//______________________________________________________________________________
void TTreeViewer::SetScanFileName(const char *name)
{
// Set the name of the file where to redirect <Scan> output.
if (fTree) ((TTreePlayer *)fTree->GetPlayer())->SetScanFileName(name);
}
//______________________________________________________________________________
void TTreeViewer::SetScanRedirect(Bool_t mode)
{
// Set the state of Scan check button.
if (mode)
fBarScan->SetState(kButtonDown);
else
fBarScan->SetState(kButtonUp);
}
//______________________________________________________________________________
void TTreeViewer::SetTreeName(const char* treeName)
{
// Allow geting the tree from the context menu.
if (!treeName) return;
TTree *tree = (TTree *) gROOT->FindObject(treeName);
if (fTreeList) {
if (fTreeList->FindObject(treeName)) {
printf("Tree found\n");
TIter next(fTreeList);
Int_t index = 0;
while ((tree = (TTree*)next())) {
if (!strcmp(treeName, tree->GetName())) {printf("found at index %i\n", index);break;}
index++;
}
SwitchTree(index);
if (fTree != fMappedTree) {
// switch also the global "tree" variable
fLVContainer->RemoveNonStatic();
// map it on the right panel
MapTree(fTree);
fListView->Layout();
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
TGListTreeItem *item = fLt->FindChildByName(parent, fTree->GetName());
fLt->ClearHighlighted();
fLt->HighlightItem(item);
fClient->NeedRedraw(fLt);
}
return;
}
}
if (!tree) return;
// ((TTreePlayer *)tree->GetPlayer())->SetViewer(this);
if (fTree != tree) {
fTree = tree;
// load the tree via the interpreter
// define a global "tree" variable for the same tree
TString command = TString::Format("tv__tree = (TTree *) gROOT->FindObject(\"%s\");", treeName);
ExecuteCommand(command.Data());
}
//--- add the tree to the list if it is not already in
if (fTreeList) fTreeList->Add(fTree);
ExecuteCommand("tv__tree_list->Add(tv__tree);");
//--- map this tree
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
if (!parent) parent = fLt->AddItem(base, "TreeList", new ULong_t(kLTNoType));
ULong_t *itemType = new ULong_t((fTreeIndex << 8) | kLTTreeType);
fTreeIndex++;
TGListTreeItem *lTreeItem = fLt->AddItem(parent, treeName, itemType,
gClient->GetPicture("tree_t.xpm"), gClient->GetPicture("tree_t.xpm"));
MapTree(fTree, lTreeItem, kFALSE);
fLt->OpenItem(parent);
fLt->HighlightItem(lTreeItem);
fClient->NeedRedraw(fLt);
//--- map slider and list view
SwitchTree(fTreeIndex-1);
fLVContainer->RemoveNonStatic();
MapTree(fTree);
fListView->Layout();
SetFile();
}
//______________________________________________________________________________
void TTreeViewer::SetFile()
{
// Set file name containing the tree.
if (!fTree) return;
TSeqCollection *list = gROOT->GetListOfFiles();
TTree *tree;
TIter next(list);
TObject *obj;
TFile *file;
while ((obj=next())) {
file = (TFile*)obj;
if (file) {
tree = (TTree*)file->Get(fTree->GetName());
if (tree) {
fFilename = file->GetName();
cout << "File name : "<< fFilename << endl;
return;
} else {
fFilename = "";
}
}
}
fFilename = "";
}
//______________________________________________________________________________
void TTreeViewer::BuildInterface()
{
// Create all viewer widgets.
//--- timer & misc
fCounting = kFALSE;
fScanMode = kFALSE;
fEnableCut = kTRUE;
fTimer = new TTimer(this, 20, kTRUE);
fLastOption = "";
fSession = new TTVSession(this);
//--- cursors
fDefaultCursor = gVirtualX->CreateCursor(kPointer);
fWatchCursor = gVirtualX->CreateCursor(kWatch);
//--- colours
ULong_t color;
gClient->GetColorByName("blue",color);
//--- pictures for X, Y and Z expression items
fPicX = gClient->GetPicture("x_pic.xpm");
fPicY = gClient->GetPicture("y_pic.xpm");
fPicZ = gClient->GetPicture("z_pic.xpm");
//--- general context menu
fContextMenu = new TContextMenu("TreeViewer context menu","");
fMappedTree = 0;
fMappedBranch = 0;
fDialogBox = 0;
fDimension = 0;
fVarDraw = kFALSE;
fStopMapping = kFALSE;
// fFilename = "";
fSourceFile = "treeviewer.C";
//--- lists : trees and widgets to be removed
// fTreeList = 0;
fTreeIndex = 0;
fWidgets = new TList();
//--- create menus --------------------------------------------------------
//--- File menu
fFileMenu = new TGPopupMenu(fClient->GetRoot());
fFileMenu->AddEntry("&New canvas", kFileCanvas);
fFileMenu->AddEntry("Open &tree file...", kFileBrowse);
fFileMenu->AddEntry("&Load Library...", kFileLoadLibrary);
fFileMenu->AddEntry("&Open session", kFileOpenSession);
fFileMenu->AddEntry("&Save source", kFileSaveMacro);
fFileMenu->AddSeparator();
fFileMenu->AddEntry("&Print", kFilePrint);
fFileMenu->AddEntry("&Close", kFileClose);
fFileMenu->AddSeparator();
fFileMenu->AddEntry("&Quit ROOT", kFileQuit);
fFileMenu->DisableEntry(kFilePrint);
//--- Edit menu
fEditMenu = new TGPopupMenu(gClient->GetRoot());
fEditMenu->AddEntry("&Expression...", kEditExpression);
fEditMenu->AddEntry("&Cut...", kEditCut);
fEditMenu->AddEntry("&Macro...", kEditMacro);
fEditMenu->AddEntry("E&Vent...", kEditEvent);
fEditMenu->DisableEntry(kEditMacro);
fEditMenu->DisableEntry(kEditEvent);
//---Run menu
fRunMenu = new TGPopupMenu(gClient->GetRoot());
fRunMenu->AddEntry("&Macro...", kRunMacro);
fRunMenu->DisableEntry(kRunMacro);
//--- Options menu
//--- General options
fOptionsGen = new TGPopupMenu(gClient->GetRoot());
fOptionsGen->AddEntry("Default", kOptionsGeneral);
fOptionsGen->AddSeparator();
fOptionsGen->AddEntry("Axis only", kOptionsGeneral+1); // "AXIS"
fOptionsGen->AddEntry("Contour only", kOptionsGeneral+2); // "HIST"
fOptionsGen->AddEntry("Superimpose", kOptionsGeneral+3); //"SAME"
fOptionsGen->AddEntry("Cylindrical", kOptionsGeneral+4); //"CYL"
fOptionsGen->AddEntry("Polar", kOptionsGeneral+5); //"POL"
fOptionsGen->AddEntry("Spherical", kOptionsGeneral+6); //"SPH"
fOptionsGen->AddEntry("PsRap/Phi", kOptionsGeneral+7); //"PSR"
fOptionsGen->AddEntry("Lego HLR", kOptionsGeneral+8); //"LEGO"
fOptionsGen->AddEntry("Lego HSR", kOptionsGeneral+9); //"LEGO1"
fOptionsGen->AddEntry("Lego Color", kOptionsGeneral+10); //"LEGO2"
fOptionsGen->AddEntry("Surface HLR", kOptionsGeneral+11); //"SURF"
fOptionsGen->AddEntry("Surface HSR", kOptionsGeneral+12); //"SURF1"
fOptionsGen->AddEntry("Surface Col", kOptionsGeneral+13); //"SURF2"
fOptionsGen->AddEntry("Surf+Cont", kOptionsGeneral+14); //"SURF3"
fOptionsGen->AddEntry("Gouraud", kOptionsGeneral+15); //"SURF4"
fOptionsGen->Associate(this);
//--- 1D options
fOptions1D = new TGPopupMenu(gClient->GetRoot());
fOptions1D->AddEntry("Default", kOptions1D);
fOptions1D->AddSeparator();
fOptions1D->AddEntry("No labels/ticks", kOptions1D+1); // "AH"
fOptions1D->AddEntry("Bar chart", kOptions1D+2); // "B"
fOptions1D->AddEntry("Smooth curve", kOptions1D+3); // "C"
fOptions1D->AddEntry("Errors", kOptions1D+4); // "E"
fOptions1D->AddEntry("Errors 1", kOptions1D+5); // "E1"
fOptions1D->AddEntry("Errors 2", kOptions1D+6); // "E2"
fOptions1D->AddEntry("Errors 3", kOptions1D+7); // "E3"
fOptions1D->AddEntry("Errors 4", kOptions1D+8); // "E4"
fOptions1D->AddEntry("Line", kOptions1D+9); // "L"
fOptions1D->AddEntry("Markers", kOptions1D+10); // "P"
fOptions1D->AddEntry("Stars", kOptions1D+11); // "*H"
fOptions1D->Associate(this);
//--- 2D options
fOptions2D = new TGPopupMenu(gClient->GetRoot());
fOptions2D->AddEntry("Default", kOptions2D);
fOptions2D->AddSeparator();
fOptions2D->AddEntry("Arrows", kOptions2D+1); // "ARR"
fOptions2D->AddEntry("Box/Surf", kOptions2D+2); // "BOX"
fOptions2D->AddEntry("Box/Color", kOptions2D+3); // "COL"
fOptions2D->AddEntry("Box/ColMap", kOptions2D+4); // "COLZ"
fOptions2D->AddEntry("Contour", kOptions2D+5); // "CONT"
fOptions2D->AddEntry("Contour 0", kOptions2D+6); // "CONT0"
fOptions2D->AddEntry("Contour 1", kOptions2D+7); // "CONT1"
fOptions2D->AddEntry("Contour 2", kOptions2D+8); // "CONT2"
fOptions2D->AddEntry("Contour 3", kOptions2D+9); // "CONT3"
fOptions2D->AddEntry("No front-box", kOptions2D+10); // "FB"
fOptions2D->AddEntry("No back-box", kOptions2D+11); // "BB"
fOptions2D->AddEntry("Scatter", kOptions2D+12); // "SCAT"
fOptions2D->AddEntry("Profile", kOptions2D+13); // "SCAT"
fOptions2D->Associate(this);
fOptionsMenu = new TGPopupMenu(gClient->GetRoot());
fOptionsMenu->AddPopup("&General Options...", fOptionsGen);
fOptionsMenu->AddPopup("&1D Options", fOptions1D);
fOptionsMenu->AddPopup("&2D Options", fOptions2D);
fOptionsMenu->AddSeparator();
fOptionsMenu->AddEntry("&Reset options", kOptionsReset);
//--- Help menu
fHelpMenu = new TGPopupMenu(gClient->GetRoot());
fHelpMenu->AddEntry("&About ROOT...", kHelpAbout);
fHelpMenu->AddEntry("&About TreeViewer...", kHelpAboutTV);
fHelpMenu->AddSeparator();
fHelpMenu->AddEntry("&Starting...", kHelpStart);
fHelpMenu->AddEntry("&Layout...", kHelpLayout);
fHelpMenu->AddEntry("&Open/Save", kHelpOpenSave);
fHelpMenu->AddEntry("&Dragging...", kHelpDragging);
fHelpMenu->AddEntry("&Editing expressions...",kHelpEditing);
fHelpMenu->AddEntry("&Session...", kHelpSession);
fHelpMenu->AddEntry("&User commands...", kHelpCommands);
fHelpMenu->AddEntry("&Context menus...", kHelpContext);
fHelpMenu->AddEntry("D&rawing...", kHelpDrawing);
fHelpMenu->AddEntry("&Macros...", kHelpMacros);
fFileMenu->Associate(this);
fEditMenu->Associate(this);
fRunMenu->Associate(this);
fOptionsMenu->Associate(this);
fHelpMenu->Associate(this);
//--- menubar layout hints
fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0,0,1,1);
fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);
//--- create menubar and add popup menus
fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
fMenuBar->AddPopup("&File", fFileMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Edit", fEditMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Run", fRunMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Options", fOptionsMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Help", fHelpMenu, fMenuBarHelpLayout);
AddFrame(fMenuBar, fMenuBarLayout);
//--- toolbar ----------------------------------------------------------------
fToolBar = new TGToolBar(this, 10, 10, kHorizontalFrame);
fBarLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX);
TGLayoutHints *lo;
lo = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 4,4,0,0);
fWidgets->Add(lo);
//--- label for Command text entry
fBarLbl1 = new TGLabel(fToolBar,"Command");
fToolBar->AddFrame(fBarLbl1,lo);
//--- command text entry
fBarCommand = new TGTextEntry(fToolBar, new TGTextBuffer(250),kBarCommand);
fBarCommand->SetWidth(120);
fBarCommand->Associate(this);
fBarCommand->SetToolTipText("User commands executed via interpreter. Type <ENTER> to execute");
fToolBar->AddFrame(fBarCommand, lo);
//--- first vertical separator
TGVertical3DLine *vSeparator = new TGVertical3DLine(fToolBar);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 4,4,0,0);
fWidgets->Add(lo);
fWidgets->Add(vSeparator);
fToolBar->AddFrame(vSeparator, lo);
lo = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 4,4,0,0);
fWidgets->Add(lo);
//--- label for Option text entry
fBarLbl2 = new TGLabel(fToolBar,"Option");
fToolBar->AddFrame(fBarLbl2, lo);
//--- drawing option text entry
fBarOption = new TGTextEntry(fToolBar, new TGTextBuffer(200),kBarOption);
fBarOption->SetWidth(100);
fBarOption->Associate(this);
fBarOption->SetToolTipText("Histogram graphics option. Type option here and click <Draw> (or <ENTER> to update current histogram).");
fToolBar->AddFrame(fBarOption, lo);
//--- second vertical separator
vSeparator = new TGVertical3DLine(fToolBar);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 4,4,0,0);
fWidgets->Add(lo);
fWidgets->Add(vSeparator);
fToolBar->AddFrame(vSeparator, lo);
lo = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 4,4,0,0);
fWidgets->Add(lo);
//--- label for Histogram text entry
fBarLbl3 = new TGLabel(fToolBar,"Histogram");
fToolBar->AddFrame(fBarLbl3, lo);
//--- histogram name text entry
fBarHist = new TGTextEntry(fToolBar, new TGTextBuffer(100));
fBarHist->SetWidth(50);
fBarHist->SetText("htemp");
fBarHist->SetToolTipText("Name of the histogram created by <Draw> command.");
fToolBar->AddFrame(fBarHist, lo);
//--- Hist check button
fBarH = new TGCheckButton(fToolBar, "Hist");
fBarH->SetToolTipText("Checked : redraw only current histogram");
fBarH->SetState(kButtonUp);
fToolBar->AddFrame(fBarH, lo);
//--- Scan check button
fBarScan = new TGCheckButton(fToolBar, "Scan");
fBarScan->SetState(kButtonUp);
fBarScan->SetToolTipText("Check to redirect TTree::Scan command in a file");
fToolBar->AddFrame(fBarScan, lo);
//--- Rec check button
fBarRec = new TGCheckButton(fToolBar, "Rec");
fBarRec->SetState(kButtonDown);
fBarRec->SetToolTipText("Check to record commands in history file and be verbose");
fToolBar->AddFrame(fBarRec, lo);
//--- 1'st horizontal tool bar separator ----------------------------------------
TGHorizontal3DLine *toolBarSep = new TGHorizontal3DLine(this);
fWidgets->Add(toolBarSep);
AddFrame(toolBarSep, fBarLayout);
AddFrame(fToolBar, fBarLayout);
//--- 2'nd horizontal tool bar separator ----------------------------------------
toolBarSep = new TGHorizontal3DLine(this);
fWidgets->Add(toolBarSep);
AddFrame(toolBarSep, fBarLayout);
//--- Horizontal mother frame ---------------------------------------------------
fHf = new TGHorizontalFrame(this, 10, 10);
//--- Vertical frames
fSlider = new TGDoubleVSlider(fHf, 10, kDoubleScaleBoth, kSLIDER);
// fSlider->SetBackgroundColor(color);
fSlider->Associate(this);
//--- fV1 -----------------------------------------------------------------------
fV1 = new TGVerticalFrame(fHf, 10, 10, kFixedWidth);
fTreeHdr = new TGCompositeFrame(fV1, 10, 10, kSunkenFrame | kVerticalFrame);
fLbl1 = new TGLabel(fTreeHdr, "Current Folder");
lo = new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY, 3, 0, 0, 0);
fWidgets->Add(lo);
fTreeHdr->AddFrame(fLbl1, lo);
lo = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 0, 1, 0);
fWidgets->Add(lo);
fV1->AddFrame(fTreeHdr, lo);
//--- tree view canvas on the left
fTreeView = new TGCanvas(fV1, fV1->GetWidth(), 10, kSunkenFrame | kDoubleBorder);
//--- container frame
fLt = new TGListTree(fTreeView->GetViewPort(), 10, 10, kHorizontalFrame,
GetWhitePixel());
fLt->Associate(this);
fTreeView->SetContainer(fLt);
lo = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 2,0,0,0);
fWidgets->Add(lo);
fV1->AddFrame(fTreeView, lo);
//--- button horizontal frame
fHpb = new TGHorizontalFrame(fV1, fTreeHdr->GetWidth(), 10, kSunkenFrame);
//--- DRAW button
fPicDraw = gClient->GetPicture("draw_t.xpm");
fDRAW = new TGPictureButton(fHpb,fPicDraw,kDRAW);
fDRAW->SetToolTipText("Draw current selection");
fDRAW->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fDRAW, lo);
//--- SPIDER button
fSPIDER = new TGTextButton(fHpb,"SPIDER");
fSPIDER->SetToolTipText("Scan current selection using a spider plot");
fSPIDER->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fSPIDER,lo);
//---connect SPIDER button to ExecuteScan() method
fSPIDER->Connect("Clicked()","TTreeViewer",this,"ExecuteSpider()");
//--- STOP button (breaks current operation)
// fPicStop = gClient->GetPicture("mb_stop_s.xpm");
fPicStop = gClient->GetPicture("stop_t.xpm");
fSTOP = new TGPictureButton(fHpb,fPicStop,kSTOP);
fSTOP->SetToolTipText("Abort current operation");
fSTOP->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fSTOP, lo);
//--- REFR button (breaks current operation)
fPicRefr = gClient->GetPicture("refresh2.xpm");
fREFR = new TGPictureButton(fHpb,fPicRefr,kDRAW);
fREFR->SetToolTipText("Update the tree viewer");
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fREFR, lo);
//---connect REFR button to DoRefresh() method
fREFR->Connect("Clicked()", "TTreeViewer", this, "DoRefresh()");
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,2,2);
fWidgets->Add(lo);
fV1->AddFrame(fHpb, lo);
//--- fV2
fV2 = new TGVerticalFrame(fHf, 10, 10);
fListHdr = new TGCompositeFrame(fV2, 10, 10, kSunkenFrame | kFitHeight);
fLbl2 = new TGLabel(fListHdr, "Current Tree: ");
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 3, 0, 0, 0);
fWidgets->Add(lo);
fListHdr->AddFrame(fLbl2, lo);
//--- progress bar
fProgressBar = new TGHProgressBar(fListHdr);
fProgressBar->SetBarColor("red");
fProgressBar->SetFillType(TGProgressBar::kBlockFill);
lo = new TGLayoutHints(kLHintsBottom | kLHintsExpandX, 2,2,4,2);
fWidgets->Add(lo);
fListHdr->AddFrame(fProgressBar, lo);
lo = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY, 2,0,1,2);
fWidgets->Add(lo);
fV2->AddFrame(fListHdr, lo);
fV1->Resize(fTreeHdr->GetDefaultWidth()+100, fV1->GetDefaultHeight());
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
fWidgets->Add(lo);
fHf->AddFrame(fSlider, lo);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
fWidgets->Add(lo);
fHf->AddFrame(fV1, lo);
//--- vertical splitter
TGVSplitter *splitter = new TGVSplitter(fHf);
splitter->SetFrame(fV1,kTRUE);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
fWidgets->Add(splitter);
fWidgets->Add(lo);
fHf->AddFrame(splitter,lo);
//-- listview for the content of the tree/branch -----------------------------
fListView = new TGListView(fListHdr,400,300);
//--- container frame
fLVContainer = new TTVLVContainer(fListView->GetViewPort(),400,300);
fLVContainer->Associate(this);
fLVContainer->SetListView(fListView);
fLVContainer->SetViewer(this);
fLVContainer->SetBackgroundColor(GetWhitePixel());
fListView->GetViewPort()->SetBackgroundColor(GetWhitePixel());
fListView->SetContainer(fLVContainer);
fListView->SetViewMode(kLVList);
lo = new TGLayoutHints(kLHintsRight | kLHintsTop | kLHintsExpandX | kLHintsExpandY);
fWidgets->Add(lo);
fListHdr->AddFrame(fListView,lo);
lo = new TGLayoutHints(kLHintsRight | kLHintsExpandX | kLHintsExpandY);
fWidgets->Add(lo);
fHf->AddFrame(fV2,lo);
AddFrame(fHf, lo);
//--- 3rd horizontal tool bar separator ----------------------------------------
toolBarSep = new TGHorizontal3DLine(this);
fWidgets->Add(toolBarSep);
AddFrame(toolBarSep, fBarLayout);
//--- label for IList text entry
fBFrame = new TGHorizontalFrame(this,10,10);
fBLbl4 = new TGLabel(fBFrame,"IList");
lo = new TGLayoutHints(kLHintsLeft | kLHintsBottom, 2,2,2,2);
fWidgets->Add(lo);
fBFrame->AddFrame(fBLbl4, lo);
//--- IList text entry
fBarListIn = new TGTextEntry(fBFrame, new TGTextBuffer(100));
fBarListIn->SetWidth(60);
fBarListIn->SetToolTipText("Name of a previously created event list");
fBFrame->AddFrame(fBarListIn, lo);
//--- label for OList text entry
fBLbl5 = new TGLabel(fBFrame,"OList");
fBFrame->AddFrame(fBLbl5, lo);
//--- OList text entry
fBarListOut = new TGTextEntry(fBFrame, new TGTextBuffer(100));
fBarListOut->SetWidth(60);
fBarListOut->SetToolTipText("Output event list. Use <Draw> to generate it.");
fBFrame->AddFrame(fBarListOut, lo);
//--- Status bar
fStatusBar = new TGStatusBar(fBFrame, 10, 10);
fStatusBar->SetWidth(200);
fStatusBar->Draw3DCorner(kFALSE);
lo = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsLeft | kLHintsExpandX, 2,2,2,2);
fWidgets->Add(lo);
fBFrame->AddFrame(fStatusBar, lo);
//--- RESET button
fReset = new TGTextButton(fBFrame,"RESET",kRESET);
fReset->SetToolTipText("Reset variable's fields and drawing options");
fReset->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsRight, 2,2,2,2);
fWidgets->Add(lo);
fBFrame->AddFrame(fReset,lo);
//--- group of buttons for session handling
fBGFirst = new TGPictureButton(fBFrame,
gClient->GetPicture("first_t.xpm"), kBGFirst);
fBGFirst->SetToolTipText("First record");
fBGFirst->Associate(this);
fBGPrevious = new TGPictureButton(fBFrame,
gClient->GetPicture("previous_t.xpm"), kBGPrevious);
fBGPrevious->SetToolTipText("Previous record");
fBGPrevious->Associate(this);
fBGRecord = new TGPictureButton(fBFrame,
gClient->GetPicture("record_t.xpm"), kBGRecord);
fBGRecord->SetToolTipText("Record");
fBGRecord->Associate(this);
fBGNext = new TGPictureButton(fBFrame,
gClient->GetPicture("next_t.xpm"), kBGNext);
fBGNext->SetToolTipText("Next record");
fBGNext->Associate(this);
fBGLast = new TGPictureButton(fBFrame,
gClient->GetPicture("last_t.xpm"), kBGLast);
fBGLast->SetToolTipText("Last record");
fBGLast->Associate(this);
fCombo = new TGComboBox(fBFrame, 0);
fCombo->SetHeight(fReset->GetDefaultHeight());
fCombo->SetWidth(100);
fCombo->Associate(this);
lo = new TGLayoutHints(kLHintsCenterY | kLHintsRight, 0,0,2,0);
fWidgets->Add(lo);
fBFrame->AddFrame(fCombo, lo);
fBFrame->AddFrame(fBGLast, lo);
fBFrame->AddFrame(fBGNext, lo);
fBFrame->AddFrame(fBGRecord, lo);
fBFrame->AddFrame(fBGPrevious, lo);
fBFrame->AddFrame(fBGFirst, lo);
lo = new TGLayoutHints(kLHintsExpandX,2,2,2,0);
fWidgets->Add(lo);
AddFrame(fBFrame,lo);
// map the window
SetWindowName("TreeViewer");
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
// put default items in the listview on the right
const TGPicture *pic, *spic;
fLVContainer->RemoveAll();
TTVLVEntry* entry;
Char_t symbol;
entry = new TTVLVEntry(fLVContainer,fPicX,fPicX,new TGString(),0,kLVSmallIcons);
symbol = 'X';
entry->SetUserData(new ULong_t((symbol << 8) | kLTExpressionType | kLTTreeType));
entry->SetToolTipText("X expression. Drag and drop expressions here");
//--- X item
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
entry = new TTVLVEntry(fLVContainer,fPicY,fPicY,new TGString(),0,kLVSmallIcons);
symbol = 'Y';
entry->SetUserData(new ULong_t((symbol << 8) | kLTExpressionType | kLTTreeType));
entry->SetToolTipText("Y expression. Drag and drop expressions here");
//--- Y item
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
entry = new TTVLVEntry(fLVContainer,fPicZ,fPicZ,new TGString(),0,kLVSmallIcons);
symbol = 'Z';
entry->SetUserData(new ULong_t((symbol << 8) | kLTExpressionType | kLTTreeType));
entry->SetToolTipText("Z expression. Drag and drop expressions here");
//--- Z item
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
pic = gClient->GetPicture("cut_t.xpm");
spic = gClient->GetPicture("cut_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,new TGString(),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTCutType));
entry->SetToolTipText("Active cut. Double-click to enable/disable");
//--- Cut item (scissors icon)
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
pic = gClient->GetPicture("pack_t.xpm");
spic = gClient->GetPicture("pack-empty_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,new TGString("Scan box"),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTPackType));
entry->SetToolTipText("Drag and drop expressions/leaves here. Double-click to scan. Check <Scan> to redirect on file.");
//--- Scan Box
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetTrueName("");
//--- 10 expression items
fNexpressions = 10;
for (Int_t i=0; i<fNexpressions; i++) {
pic = gClient->GetPicture("expression_t.xpm");
spic = gClient->GetPicture("expression_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,new TGString(),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTDragType));
entry->SetToolTipText("User defined expression/cut. Double-click to edit");
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
}
fListView->Layout();
fListView->Resize();
// EmptyAll();
// map the tree if it was supplied in the constructor
if (!fTree) {
fSlider->SetRange(0,1000000);
fSlider->SetPosition(0,1000000);
} else {
fSlider->SetRange(0,fTree->GetEntries()-1);
fSlider->SetPosition(0,fTree->GetEntries()-1);
}
PrintEntries();
fProgressBar->SetPosition(0);
fProgressBar->ShowPosition();
ActivateButtons(kFALSE, kFALSE, kFALSE, kFALSE);
// map the window
///SetWindowName("TreeViewer");
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
}
//______________________________________________________________________________
TTreeViewer::~TTreeViewer()
{
// TTreeViewer destructor.
if (!gClient) return;
gClient->FreePicture(fPicX);
gClient->FreePicture(fPicY);
gClient->FreePicture(fPicZ);
gClient->FreePicture(fPicDraw);
gClient->FreePicture(fPicStop);
gClient->FreePicture(fPicRefr);
fDialogBox = TGSelectBox::GetInstance();
if (fDialogBox) delete fDialogBox;
delete fContextMenu;
delete fBarLbl1;
delete fBarLbl2;
delete fBarLbl3;
delete fBLbl4;
delete fBLbl5;
delete fBarCommand;
delete fBarOption;
delete fBarHist;
delete fBarListIn;
delete fBarListOut;
delete fBarH;
delete fBarScan;
delete fBarRec;
delete fToolBar;
delete fSlider;
delete fV1;
delete fV2;
delete fLbl1;
delete fLbl2;
delete fHf;
delete fTreeHdr;
delete fListHdr;
delete fLt;
delete fTreeView;
delete fLVContainer;
delete fListView;
delete fProgressBar;
delete fHpb;
delete fDRAW;
delete fSPIDER;
delete fSTOP;
delete fReset;
delete fBGFirst;
delete fBGPrevious;
delete fBGRecord;
delete fBGNext;
delete fBGLast;
delete fCombo;
delete fBFrame;
delete fMenuBar;
delete fFileMenu;
delete fEditMenu;
delete fOptionsGen;
delete fOptions1D;
delete fOptions2D;
delete fOptionsMenu;
delete fHelpMenu;
delete fMenuBarLayout;
delete fMenuBarItemLayout;
delete fMenuBarHelpLayout;
delete fBarLayout;
fWidgets->Delete();
delete fWidgets;
if (fTreeList) {
delete fTreeList;
}
delete fTimer;
delete fSession;
}
//______________________________________________________________________________
void TTreeViewer::ActivateButtons(Bool_t first, Bool_t previous,
Bool_t next, Bool_t last)
{
// Enable/disable session buttons.
if (first) fBGFirst->SetState(kButtonUp);
else fBGFirst->SetState(kButtonDisabled);
if (previous) fBGPrevious->SetState(kButtonUp);
else fBGPrevious->SetState(kButtonDisabled);
if (next) fBGNext->SetState(kButtonUp);
else fBGNext->SetState(kButtonDisabled);
if (last) fBGLast->SetState(kButtonUp);
else fBGLast->SetState(kButtonDisabled);
}
//______________________________________________________________________________
const char* TTreeViewer::Cut()
{
// Apply Cut
return fLVContainer->Cut();
}
//______________________________________________________________________________
const char* TTreeViewer::ScanList()
{
// returns scanlist
return fLVContainer->ScanList();
}
//______________________________________________________________________________
void TTreeViewer::SetSession(TTVSession *session)
{
// Set current session
if (session) {
delete fSession;
fSession = session;
}
}
//______________________________________________________________________________
const char* TTreeViewer::EmptyBrackets(const char* name)
{
// Empty the bracket content of a string.
TString stripped(name);
if (!stripped.Contains("[")) return name;
TString retstr(name);
TObjString *objstr;
Int_t index = 0;
while (stripped.Index("[", index) != kNPOS) {
Int_t start = stripped.Index("[", index);
Int_t end = stripped.Index("]", index);
if (end == kNPOS) {
objstr = new TObjString(retstr.Data());
fWidgets->Add(objstr);
return (objstr->GetString()).Data();
}
index = start+2;
retstr = stripped.Remove(start+1, end-start-1);
stripped = retstr;
}
objstr = new TObjString(retstr.Data());
fWidgets->Add(objstr);
return (objstr->GetString()).Data();
}
//______________________________________________________________________________
void TTreeViewer::EmptyAll()
{
// Clear the content of all items in the list view.
fLVContainer->EmptyAll();
}
//______________________________________________________________________________
void TTreeViewer::Empty()
{
// Empty the content of the selected expression.
void *p = 0;
TTVLVEntry *item = 0;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) == 0) {
Warning("Empty", "No item selected.");
return;
}
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTExpressionType)) {
Warning("Empty", "Not expression type.");
return;
}
if (*itemType & kLTPackType) {
item->SetSmallPic(fClient->GetPicture("pack-empty_t.xpm"));
item->SetTrueName("");
return;
}
item->Empty();
}
//______________________________________________________________________________
TTVLVEntry * TTreeViewer::ExpressionItem(Int_t index)
{
// Get the item from a specific position.
return fLVContainer->ExpressionItem(index);
}
//______________________________________________________________________________
TList* TTreeViewer::ExpressionList()
{
// Get the list of expression items.
return fLVContainer->ExpressionList();
}
//______________________________________________________________________________
Int_t TTreeViewer::Dimension()
{
// Compute dimension of the histogram.
fDimension = 0;
if (strlen(Ex())) fDimension++;
if (strlen(Ey())) fDimension++;
if (strlen(Ez())) fDimension++;
return fDimension;
}
//______________________________________________________________________________
void TTreeViewer::ExecuteDraw()
{
// Called when the DRAW button is executed.
TString varexp;
TString command;
Int_t dimension = 0;
TString alias[3];
TTVLVEntry *item;
Int_t i;
// fill in expressions
if (fVarDraw) {
void *p = 0;
dimension = 1;
if (!(item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p))) return;
alias[0] = item->GetAlias();
if (alias[0].BeginsWith("~")) alias[0].Remove(0, 1);
varexp = item->ConvertAliases();
} else {
if (strlen(Ez())) {
dimension++;
varexp = Ez();
item = ExpressionItem(2);
alias[2] = item->GetAlias();
if (alias[2].BeginsWith("~")) alias[2].Remove(0, 1);
}
if (strlen(Ez()) && (strlen(Ex()) || strlen(Ey()))) varexp += ":";
if (strlen(Ey())) {
dimension++;
varexp += Ey();
item = ExpressionItem(1);
alias[1] = item->GetAlias();
if (alias[1].BeginsWith("~")) alias[1].Remove(0, 1);
}
if (strlen(Ey()) && strlen(Ex())) varexp += ":";
if (strlen(Ex())) {
dimension++;
varexp += Ex();
item = ExpressionItem(0);
alias[0] = item->GetAlias();
if (alias[0].BeginsWith("~")) alias[0].Remove(0, 1);
}
}
if (!dimension && !fScanMode) {
Warning("ExecuteDraw", "Nothing to draw on X,Y,Z.");
return;
}
// find ListIn
fTree->SetEventList(0);
TEventList *elist = 0;
if (strlen(fBarListIn->GetText())) {
elist = (TEventList *) gROOT->FindObject(fBarListIn->GetText());
if (elist) fTree->SetEventList(elist);
}
// find ListOut
if (strlen(fBarListOut->GetText())) varexp = TString::Format(">>%s", fBarListOut->GetText());
// find histogram name
if (strcmp("htemp", fBarHist->GetText())) {
varexp += ">>";
varexp += fBarHist->GetText();
}
// find canvas/pad where to draw
TPad *pad = (TPad*)gROOT->GetSelectedPad();
if (pad) pad->cd();
// find graphics option
const char* gopt = fBarOption->GetText();
// just in case a previous interrupt was posted
gROOT->SetInterrupt(kFALSE);
// check if cut is enabled
const char *cut = "";
if (fEnableCut) cut = Cut();
// get entries to be processed
Long64_t nentries = (Long64_t)(fSlider->GetMaxPosition() -
fSlider->GetMinPosition() + 1);
Long64_t firstentry =(Long64_t) fSlider->GetMinPosition();
//printf("firstentry=%lld, nentries=%lld\n",firstentry,nentries);
// check if Scan is checked and if there is something in the box
if (fScanMode) {
// fBarScan->SetState(kButtonUp);
fScanMode = kFALSE;
if (strlen(ScanList())) varexp = ScanList();
command = TString::Format("tv__tree->Scan(\"%s\",\"%s\",\"%s\", %lld, %lld);",
varexp.Data(), cut, gopt, nentries, firstentry);
if (fBarScan->GetState() == kButtonDown) {
((TTreePlayer *)fTree->GetPlayer())->SetScanRedirect(kTRUE);
} else {
((TTreePlayer *)fTree->GetPlayer())->SetScanRedirect(kFALSE);
}
ExecuteCommand(command.Data(), kTRUE);
return;
}
// check if only histogram has to be updated
if (fBarH->GetState() == kButtonDown) {
// reset 'Hist' mode
fBarH->SetState(kButtonUp);
TH1 *hist = fTree->GetHistogram();
if (hist && gPad) {
//hist = (TH1*)gPad->GetListOfPrimitives()->FindObject(fBarHist->GetText());
if (hist) {
// check if graphic option was modified
TString last(fLastOption);
TString current(gopt);
current.ToUpper();
last.ToUpper();
if (current == last) {
gPad->Update();
return;
}
if (dimension == 3 && strlen(gopt)) {
cout << "Graphics option " << gopt << " not valid for 3D histograms" << endl;
return;
}
cout << " Graphics option for current histogram changed to " << gopt << endl;
hist->Draw(gopt);
fLastOption = fBarOption->GetText();
gPad->Update();
return;
}
}
}
// send draw command
fLastOption = fBarOption->GetText();
if (!strlen(gopt) && dimension!=3)
//{
// gopt = "hist";
// fLastOption = "hist";
//}
if (dimension == 3 && strlen(gopt)) {
cout << "Graphics option " << gopt << " not valid for 3D histograms" << endl;
gopt = "";
fLastOption = "";
}
command = TString::Format("tv__tree->Draw(\"%s\",\"%s\",\"%s\", %lld, %lld);",
varexp.Data(), cut, gopt, nentries, firstentry);
if (fCounting) return;
fCounting = kTRUE;
fTree->SetTimerInterval(200);
fTimer->TurnOn();
ExecuteCommand(command.Data());
HandleTimer(fTimer);
fTimer->TurnOff();
fTree->SetTimerInterval(0);
fCounting = kFALSE;
fProgressBar->SetPosition(0);
fProgressBar->ShowPosition();
TH1 *hist = fTree->GetHistogram();
if (hist) {
// put expressions aliases on axes
Int_t current = 0;
for (i=0; i<3; i++) {
if (alias[i].Length()) {
if (i != current) {
alias[current] = alias[i];
alias[i] = "";
}
current++;
}
}
//hist = (TH1*)gPad->GetListOfPrimitives()->FindObject(fBarHist->GetText());
TAxis *axis[3];
axis[0] = hist->GetXaxis();
axis[1] = hist->GetYaxis();
axis[2] = hist->GetZaxis();
for (Int_t ind=0; ind<3; ind++) axis[ind]->SetTitle(alias[ind].Data());
}
if (gPad) gPad->Update();
}
//______________________________________________________________________________
void TTreeViewer::ExecuteSpider()
{
// Draw a spider plot for the selected entries.
TString varexp;
Int_t dimension = 0;
TString alias[3];
TTVLVEntry *item;
Bool_t previousexp = kFALSE;
// fill in expressions
if (strlen(Ez())) {
previousexp = kTRUE;
dimension++;
varexp = Ez();
item = ExpressionItem(2);
alias[2] = item->GetAlias();
if (alias[2].BeginsWith("~")) alias[2].Remove(0, 1);
}
if (strlen(Ez()) && (strlen(Ex()) || strlen(Ey()))) varexp += ":";
if (strlen(Ey())) {
previousexp = kTRUE;
dimension++;
varexp += Ey();
item = ExpressionItem(1);
alias[1] = item->GetAlias();
if (alias[1].BeginsWith("~")) alias[1].Remove(0, 1);
}
if (strlen(Ey()) && strlen(Ex())) varexp += ":";
if (strlen(Ex())) {
previousexp = kTRUE;
dimension++;
varexp += Ex();
item = ExpressionItem(0);
alias[0] = item->GetAlias();
if (alias[0].BeginsWith("~")) alias[0].Remove(0, 1);
}
for(Int_t i=0;i<10;++i){
if(strlen(En(i+5))){
++dimension;
if(previousexp){
varexp += ":";
varexp += En(i+5);
} else varexp = En(i+5);
previousexp = kTRUE;
}
}
if (dimension<3) {
Warning("ExecuteSpider", "Need at least 3 variables");
return;
}
// find ListIn
fTree->SetEventList(0);
TEventList *elist = 0;
if (strlen(fBarListIn->GetText())) {
elist = (TEventList *) gROOT->FindObject(fBarListIn->GetText());
if (elist) fTree->SetEventList(elist);
}
// find ListOut
if (strlen(fBarListOut->GetText())) varexp = TString::Format(">>%s", fBarListOut->GetText());
// find canvas/pad where to draw
TPad *pad = (TPad*)gROOT->GetSelectedPad();
if (pad) pad->cd();
// find graphics option
const char* gopt = fBarOption->GetText();
// just in case a previous interrupt was posted
gROOT->SetInterrupt(kFALSE);
// check if cut is enabled
const char *cut = "";
if (fEnableCut) cut = Cut();
// get entries to be processed
Long64_t nentries = (Long64_t)(fSlider->GetMaxPosition() -
fSlider->GetMinPosition() + 1);
Long64_t firstentry =(Long64_t) fSlider->GetMinPosition();
// create the spider plot
TSpider* spider = new TSpider(fTree,varexp.Data(),cut,Form("%s spider average",gopt),nentries,firstentry);
spider->Draw();
if (gPad) gPad->Update();
}
//______________________________________________________________________________
const char* TTreeViewer::Ex()
{
// Get the expression to be drawn on X axis.
return fLVContainer->Ex();
}
//______________________________________________________________________________
const char* TTreeViewer::Ey()
{
// Get the expression to be drawn on Y axis.
return fLVContainer->Ey();
}
//______________________________________________________________________________
const char* TTreeViewer::Ez()
{
// Get the expression to be drawn on Z axis.
return fLVContainer->Ez();
}
//______________________________________________________________________________
const char* TTreeViewer::En(Int_t n)
{
// Get the n'th expression
TTVLVEntry *e = fLVContainer->ExpressionItem(n);
if(e) return e->ConvertAliases();
return "";
}
//______________________________________________________________________________
void TTreeViewer::EditExpression()
{
// Start the expression editor.
void *p = 0;
// get the selected item
TTVLVEntry *item = 0;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) == 0) {
Warning("EditExpression", "No item selected.");
return;
}
// check if it is an expression
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTExpressionType)) {
Warning("EditExpression", "Not expression type.");
return;
}
// check if the editor is already active
fDialogBox = TGSelectBox::GetInstance();
if (!fDialogBox) {
fDialogBox = new TGSelectBox(fClient->GetRoot(), this, fV1->GetWidth() - 10);
}
// copy current item data into editor boxes
fDialogBox->SetEntry(item);
fDialogBox->SetWindowName("Expression editor");
// check if you are editing the cut expression
if (*itemType & kLTCutType || item->IsCut()) {
fDialogBox->SetLabel("Selection");
} else {
fDialogBox->SetLabel("Expression");
}
}
//______________________________________________________________________________
Int_t TTreeViewer::MakeSelector(const char* selector)
{
// Get use of TTree::MakeSelector() via the context menu.
if (!fTree) return 0;
return fTree->MakeSelector(selector);
}
//______________________________________________________________________________
Long64_t TTreeViewer::Process(const char* filename, Option_t *option, Long64_t nentries, Long64_t firstentry)
{
// Get use of TTree::Process() via the context menu.
if (!fTree) return 0;
return fTree->Process(filename, option, nentries, firstentry);
}
//______________________________________________________________________________
const char *TTreeViewer::GetGrOpt()
{
// Get graph option
return fBarOption->GetText();
}
//______________________________________________________________________________
void TTreeViewer::SetGrOpt(const char *option)
{
// Set graph option
fBarOption->SetText(option);
}
//______________________________________________________________________________
Bool_t TTreeViewer::IsScanRedirected()
{
// Return kTRUE if scan is redirected
return (fBarScan->GetState()==kButtonDown);
}
//______________________________________________________________________________
void TTreeViewer::RemoveItem()
{
// Remove the selected item from the list.
void *p = 0;
TTVLVEntry *item = 0;
// get the selected item
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) == 0) {
Warning("RemoveItem", "No item selected.");
return;
}
// check if it is removable
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTDragType)) {
Warning("RemoveItem", "Not removable type.");
return;
}
fLVContainer->RemoveItem(item);
fListView->Layout();
}
//______________________________________________________________________________
void TTreeViewer::RemoveLastRecord()
{
// Remove the current record.
fSession->RemoveLastRecord();
}
//______________________________________________________________________________
Bool_t TTreeViewer::HandleTimer(TTimer *timer)
{
// This function is called by the fTimer object.
if (fCounting) {
Float_t first = fSlider->GetMinPosition();
Float_t last = fSlider->GetMaxPosition();
Float_t current = (Float_t)fTree->GetReadEntry();
Float_t percent = (current-first+1)/(last-first+1);
fProgressBar->SetPosition(100.*percent);
fProgressBar->ShowPosition();
}
timer->Reset();
return kFALSE;
}
//______________________________________________________________________________
Bool_t TTreeViewer::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
{
// Handle menu and other commands generated.
TRootHelpDialog *hd;
switch (GET_MSG(msg)) {
case kC_VSLIDER :
// handle slider messages
PrintEntries();
break;
case kC_TEXTENTRY:
switch (GET_SUBMSG(msg)) {
// handle enter posted by the Command text entry
case kTE_ENTER:
if ((Int_t)parm1 == kBarCommand) {
ExecuteCommand(fBarCommand->GetText());
fBarCommand->Clear();
}
if ((Int_t)parm1 == kBarOption) {
fVarDraw = kFALSE;
fBarH->SetState(kButtonDown);
ExecuteDraw();
fBarH->SetState(kButtonUp);
}
break;
default:
break;
}
break;
case kC_LISTTREE:
switch (GET_SUBMSG(msg)) {
// handle mouse messages in the list-tree (left panel)
case kCT_ITEMCLICK :
if ((parm1==kButton1) || (parm1==kButton3)) {
TGListTreeItem *ltItem = 0;
// get item that sent this
if ((ltItem = fLt->GetSelected()) != 0) {
// get item type
ULong_t *itemType = (ULong_t *)ltItem->GetUserData();
if (*itemType & kLTTreeType) {
// already mapped tree item clicked
Int_t index = (Int_t)(*itemType >> 8);
SwitchTree(index);
if (fTree != fMappedTree) {
// switch also the global "tree" variable
fLVContainer->RemoveNonStatic();
// map it on the right panel
MapTree(fTree);
fListView->Layout();
}
// activate context menu for this tree
if (parm1 == kButton3) {
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
fContextMenu->Popup(x, y, fTree);
}
}
if (*itemType & kLTBranchType) {
// branch item clicked
SetParentTree(ltItem);
if (!fTree) break; // really needed ?
TBranch *branch = fTree->GetBranch(ltItem->GetText());
if (!branch) break;
// check if it is mapped on the right panel
if (branch != fMappedBranch) {
fLVContainer->RemoveNonStatic();
MapBranch(branch);
fStopMapping = kFALSE;
fListView->Layout();
}
// activate context menu for this branch (no *MENU* methods ):)
if (parm1 == kButton3) {
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
fContextMenu->Popup(x, y, branch);
}
}
if (*itemType & kLTLeafType) {
// leaf item clicked
SetParentTree(ltItem);
if (!fTree) break;
// find parent branch
TBranch *branch = fTree->GetBranch(ltItem->GetParent()->GetText());
if (!branch) {
if (fTree != fMappedTree) {
fLVContainer->RemoveNonStatic();
MapTree(fTree);
fListView->Layout();
}
} else {
// check if it is already mapped
if (branch!=fMappedBranch) {
fLVContainer->RemoveNonStatic();
MapBranch(branch);
fStopMapping = kFALSE;
fListView->Layout();
}
}
// select corresponding leaf on the right panel
fLVContainer->SelectItem(ltItem->GetText());
if (parm1 == kButton3) {
// activate context menu for this leaf
ProcessMessage(MK_MSG(kC_CONTAINER, kCT_ITEMCLICK), kButton3, parm2);
}
}
}
}
break;
case kCT_ITEMDBLCLICK :
fClient->NeedRedraw(fLt);
if (parm1 == kButton1) {
// execute double-click action for corresponding item in the right panel
ProcessMessage(MK_MSG(kC_CONTAINER, kCT_ITEMDBLCLICK), kButton1, parm2);
}
break;
default:
break;
}
break;
case kC_COMMAND:
switch (GET_SUBMSG(msg)){
case kCM_COMBOBOX:
fSession->Show(fSession->GetRecord((Int_t)parm2));
break;
case kCM_BUTTON:
switch (parm1) {
// handle button messages
case kRESET:
EmptyAll();
break;
case kDRAW:
fVarDraw = kFALSE;
ExecuteDraw();
break;
case kSTOP:
if (fCounting)
gROOT->SetInterrupt(kTRUE);
break;
case kCLOSE:
SendCloseMessage();
break;
case kBGFirst:
fSession->Show(fSession->First());
break;
case kBGPrevious:
fSession->Show(fSession->Previous());
break;
case kBGRecord:
fSession->AddRecord();
break;
case kBGNext:
fSession->Show(fSession->Next());
break;
case kBGLast:
fSession->Show(fSession->Last());
break;
default:
break;
}
break;
case kCM_MENU:
// handle menu messages
// check if sent by Options menu
if ((parm1>=kOptionsReset) && (parm1<kHelpAbout)) {
Dimension();
if ((fDimension==0) && (parm1>=kOptions1D)) {
Warning("ProcessMessage", "Edit expressions first.");
break;
}
if ((fDimension==1) && (parm1>=kOptions2D)) {
Warning("ProcessMessage", "You have only one expression active.");
break;
}
if ((fDimension==2) && (parm1>=kOptions1D) &&(parm1<kOptions2D)) {
Warning("ProcessMessage", "1D drawing options not apply to 2D histograms.");
break;
}
// make composed option
MapOptions(parm1);
break;
}
switch (parm1) {
case kFileCanvas:
gROOT->MakeDefCanvas();
break;
case kFileBrowse:
if (1) {
static TString dir(".");
TGFileInfo info;
info.fFileTypes = gOpenTypes;
info.fIniDir = StrDup(dir);
new TGFileDialog(fClient->GetRoot(), this, kFDOpen, &info);
if (!info.fFilename) return kTRUE;
dir = info.fIniDir;
TString command = TString::Format("tv__tree_file = new TFile(\"%s\");",
gSystem->UnixPathName(info.fFilename));
ExecuteCommand(command.Data());
ExecuteCommand("tv__tree_file->ls();");
cout << "Use SetTreeName() from context menu and supply a tree name" << endl;
cout << "The context menu is activated by right-clicking the panel from right" << endl;
}
break;
case kFileLoadLibrary:
fBarCommand->SetText("gSystem->Load(\"\");");
if (1) {
Event_t event;
event.fType = kButtonPress;
event.fCode = kButton1;
fBarCommand->HandleButton(&event);
}
fBarCommand->SetCursorPosition(15);
break;
case kFileOpenSession:
if (1) {
static TString dir(".");
TGFileInfo info;
info.fFileTypes = gMacroTypes;
info.fIniDir = StrDup(dir);
new TGFileDialog(fClient->GetRoot(), this, kFDOpen, &info);
if (!info.fFilename) return kTRUE;
dir = info.fIniDir;
gInterpreter->Reset();
if (!gInterpreter->IsLoaded(info.fFilename)) gInterpreter->LoadMacro(info.fFilename);
char command[1024];
command[0] = 0;
sprintf(command,"open_session((void*)0x%lx);", (Long_t)this);
ExecuteCommand(command);
}
break;
case kFileSaveMacro:
SaveSource();
break;
case kFilePrint:
break;
case kFileClose:
SendCloseMessage();
break;
case kFileQuit:
gApplication->Terminate(0);
break;
case kEditExpression:
EditExpression();
break;
case kEditCut:
EditExpression();
break;
case kEditMacro:
break;
case kEditEvent:
break;
case kRunMacro:
break;
case kHelpAbout:
{
#ifdef R__UNIX
TString rootx;
# ifdef ROOTBINDIR
rootx = ROOTBINDIR;
# else
rootx = gSystem->Getenv("ROOTSYS");
if (!rootx.IsNull()) rootx += "/bin";
# endif
rootx += "/root -a &";
gSystem->Exec(rootx);
#else
#ifdef WIN32
new TWin32SplashThread(kTRUE);
#else
char str[32];
sprintf(str, "About ROOT %s...", gROOT->GetVersion());
hd = new TRootHelpDialog(this, str, 600, 400);
hd->SetText(gHelpAbout);
hd->Popup();
#endif
#endif
}
break;
case kHelpAboutTV:
hd = new TRootHelpDialog(this, "About TreeViewer...", 600, 400);
hd->SetText(gTVHelpAbout);
hd->Resize(hd->GetDefaultSize());
hd->Popup();
break;
case kHelpStart:
hd = new TRootHelpDialog(this, "Quick start...", 600, 400);
hd->SetText(gTVHelpStart);
hd->Popup();
break;
case kHelpLayout:
hd = new TRootHelpDialog(this, "Layout...", 600, 400);
hd->SetText(gTVHelpLayout);
hd->Popup();
break;
case kHelpOpenSave:
hd = new TRootHelpDialog(this, "Open/Save...", 600, 400);
hd->SetText(gTVHelpOpenSave);
hd->Popup();
break;
case kHelpDragging:
hd = new TRootHelpDialog(this, "Dragging items...", 600, 400);
hd->SetText(gTVHelpDraggingItems);
hd->Popup();
break;
case kHelpEditing:
hd = new TRootHelpDialog(this, "Editing expressions...", 600, 400);
hd->SetText(gTVHelpEditExpressions);
hd->Popup();
break;
case kHelpSession:
hd = new TRootHelpDialog(this, "Session...", 600, 400);
hd->SetText(gTVHelpSession);
hd->Popup();
break;
case kHelpCommands:
hd = new TRootHelpDialog(this, "Executing user commands...", 600, 400);
hd->SetText(gTVHelpUserCommands);
hd->Popup();
break;
case kHelpContext:
hd = new TRootHelpDialog(this, "Context menus...", 600, 400);
hd->SetText(gTVHelpContext);
hd->Popup();
break;
case kHelpDrawing:
hd = new TRootHelpDialog(this, "Drawing histograms...", 600, 400);
hd->SetText(gTVHelpDrawing);
hd->Popup();
break;
case kHelpMacros:
hd = new TRootHelpDialog(this, "Using macros...", 600, 400);
hd->SetText(gTVHelpMacros);
hd->Popup();
break;
default:
break;
}
break;
default:
break;
}
break;
case kC_CONTAINER:
switch (GET_SUBMSG(msg)) {
// handle messages sent from the listview (right panel)
case kCT_SELCHANGED:
break;
case kCT_ITEMCLICK:
// handle mouse messages
switch (parm1) {
case kButton1:
if (fLVContainer->NumSelected()) {
// get item that sent this
void *p = 0;
TTVLVEntry *item;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) != 0) {
const char* vname = item->GetTrueName();
TString trueName(vname);
if (trueName.Contains("[]")) {
TIter next(fTree->GetListOfLeaves());
TLeaf *leaf;
while((leaf=(TLeaf*)next())) {
if (!strcmp(vname, EmptyBrackets(leaf->GetName())))
vname = leaf->GetName();
}
}
char* msg2 = new char[2000];
// get item type
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (*itemType & kLTTreeType) {
// X, Y or Z clicked
char symbol = (char)((*itemType) >> 8);
sprintf(msg2, "%c expression : %s", symbol, vname);
} else {
if (*itemType & kLTCutType) {
// scissors clicked
sprintf(msg2, "Cut : %s", vname);
} else {
if (*itemType & kLTPackType) {
sprintf(msg2, "Box : %s", vname);
} else {
if (*itemType & kLTExpressionType) {
// expression clicked
sprintf(msg2, "Expression : %s", vname);
} else {
if (*itemType & kLTBranchType) {
sprintf(msg2, "Branch : %s", vname);
} else {
sprintf(msg2, "Leaf : %s", vname);
}
}
}
}
}
// write who is responsable for this
TString message = msg2;
message = message(0,150);
Message(msg2);
delete[] msg2;
// check if this should be pasted into the expression editor
if ((*itemType & kLTBranchType) || (*itemType & kLTCutType)) break;
fDialogBox = TGSelectBox::GetInstance();
if (!fDialogBox || !strlen(vname)) break;
if (item == fDialogBox->EditedEntry()) break;
// paste it
// char first = (char) vname[0];
TString insert(item->GetAlias());
// if (first != '(') insert += "(";
// insert += item->GetAlias();
// if (first != '(') insert += ")";
fDialogBox->GrabPointer();
fDialogBox->InsertText(insert.Data());
// put the cursor at the right position
}
}
break;
case kButton2:
break;
case kButton3:
// activate general context menu
if (fLVContainer->NumSelected()) {
void *p = 0;
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
TTVLVEntry *item = 0;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) != 0) {
fContextMenu->Popup(x, y, item->GetContext());
}
} else { // empty click
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
fContextMenu->Popup(x, y, this);
}
break;
default:
break;
}
break;
case kCT_ITEMDBLCLICK:
switch (parm1) {
case kButton1:
if (fLVContainer->NumSelected()) {
// get item that sent this
void *p = 0;
TTVLVEntry *item;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) != 0) {
// get item type
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTCutType) && !(*itemType & kLTBranchType)
&& !(*itemType & kLTPackType)) {
if (strlen(item->GetTrueName())) {
fVarDraw = kTRUE;
// draw on double-click
ExecuteDraw();
break;
} else {
// open expression in editor
EditExpression();
}
}
if (*itemType & kLTCutType) {
fEnableCut = !fEnableCut;
if (fEnableCut) {
item->SetSmallPic(gClient->GetPicture("cut_t.xpm"));
} else {
item->SetSmallPic(gClient->GetPicture("cut-disable_t.xpm"));
}
}
if (*itemType & kLTPackType) {
fScanMode = kTRUE;
ExecuteDraw();
}
}
}
break;
case kButton2:
break;
case kButton3:
break;
default:
break;
}
break;
case 4:
// cout << "Dragging Item" << endl;
default:
break;
}
break;
default:
break;
}
return kTRUE;
}
//______________________________________________________________________________
void TTreeViewer::CloseWindow()
{
// Close the viewer.
DeleteWindow();
}
//______________________________________________________________________________
void TTreeViewer::ExecuteCommand(const char* command, Bool_t fast)
{
// Execute all user commands.
// Execute the command, write it to history file and echo it to output
if (fBarRec->GetState() == kButtonDown) {
// show the command on the command line
//printf("%s\n", command);
char comm[2000];
comm[0] = 0;
if (strlen(command) > 1999) {
Warning("ExecuteCommand", "Command too long: aborting.");
return;
}
sprintf(comm, "%s", command);
// print the command to history file
Gl_histadd(comm);
}
// execute it
if (fast) {
gROOT->ProcessLineFast(command);
} else {
gROOT->ProcessLine(command);
}
// make sure that 'draw on double-click' flag is reset
fVarDraw = kFALSE;
}
//______________________________________________________________________________
void TTreeViewer::MapOptions(Long_t parm1)
{
// Scan the selected options from option menu.
Int_t ind;
if (parm1 == kOptionsReset) {
for (ind=kOptionsGeneral; ind<kOptionsGeneral+16; ind++)
fOptionsGen->UnCheckEntry(ind);
for (ind=kOptions1D; ind<kOptions1D+12; ind++)
fOptions1D->UnCheckEntry(ind);
for (ind=kOptions2D; ind<kOptions2D+14; ind++)
fOptions2D->UnCheckEntry(ind);
}
if ((parm1 < kOptions1D) && (parm1 != kOptionsReset)) {
if (fOptionsGen->IsEntryChecked((Int_t)parm1)) {
fOptionsGen->UnCheckEntry((Int_t)parm1);
} else {
fOptionsGen->CheckEntry((Int_t)parm1);
if ((Int_t)parm1 != kOptionsGeneral) fOptionsGen->UnCheckEntry((Int_t)kOptionsGeneral);
}
if (fOptionsGen->IsEntryChecked((Int_t)kOptionsGeneral)) {
// uncheck all in this menu
for (ind=kOptionsGeneral+1; ind<kOptionsGeneral+16; ind++) {
fOptionsGen->UnCheckEntry(ind);
}
}
}
if ((parm1 < kOptions2D) && (parm1 >= kOptions1D)) {
if (fOptions1D->IsEntryChecked((Int_t)parm1)) {
fOptions1D->UnCheckEntry((Int_t)parm1);
} else {
fOptions1D->CheckEntry((Int_t)parm1);
if ((Int_t)parm1 != kOptions1D) fOptions1D->UnCheckEntry((Int_t)kOptions1D);
}
if (fOptions1D->IsEntryChecked((Int_t)kOptions1D)) {
// uncheck all in this menu
for (ind=kOptions1D+1; ind<kOptions1D+12; ind++) {
fOptions1D->UnCheckEntry(ind);
}
}
}
if (parm1 >= kOptions2D) {
if (fOptions2D->IsEntryChecked((Int_t)parm1)) {
fOptions2D->UnCheckEntry((Int_t)parm1);
} else {
fOptions2D->CheckEntry((Int_t)parm1);
if ((Int_t)parm1 != kOptions2D) fOptions2D->UnCheckEntry((Int_t)kOptions2D);
}
if (fOptions2D->IsEntryChecked((Int_t)kOptions2D)) {
// uncheck all in this menu
for (ind=kOptions2D+1; ind<kOptions2D+14; ind++) {
fOptions2D->UnCheckEntry(ind);
}
}
}
// concatenate options
fBarOption->SetText("");
for (ind=kOptionsGeneral; ind<kOptionsGeneral+16; ind++) {
if (fOptionsGen->IsEntryChecked(ind))
fBarOption->AppendText(gOptgen[ind-kOptionsGeneral]);
}
if (Dimension() == 1) {
for (ind=kOptions1D; ind<kOptions1D+12; ind++) {
if (fOptions1D->IsEntryChecked(ind))
fBarOption->AppendText(gOpt1D[ind-kOptions1D]);
}
}
if (Dimension() == 2) {
for (ind=kOptions2D; ind<kOptions2D+14; ind++) {
if (fOptions2D->IsEntryChecked(ind))
fBarOption->AppendText(gOpt2D[ind-kOptions2D]);
}
}
}
//______________________________________________________________________________
void TTreeViewer::MapTree(TTree *tree, TGListTreeItem *parent, Bool_t listIt)
{
// Map current tree and expand its content (including friends) in the lists.
if (!tree) return;
TObjArray *branches = tree->GetListOfBranches();
if (!branches) return; // A Chain with no underlying trees.
TBranch *branch;
// loop on branches
Int_t id;
for (id=0; id<branches->GetEntries(); id++) {
branch = (TBranch *)branches->At(id);
if (branch->TestBit(kDoNotProcess)) continue;
TString name = branch->GetName();
if (name.Contains("fBits") || name.Contains("fUniqueID")) continue;
// now map sub-branches
MapBranch(branch, "", parent, listIt);
fStopMapping = kFALSE;
}
//Map branches of friend Trees (if any)
//Look at tree->GetTree() to insure we see both the friendss of a chain
//and the friends of the chain members
TIter nextf( tree->GetTree()->GetListOfFriends() );
TFriendElement *fr;
while ((fr = (TFriendElement*)nextf())) {
TTree * t = fr->GetTree();
branches = t->GetListOfBranches();
for (id=0; id<branches->GetEntries(); id++) {
branch = (TBranch *)branches->At(id);
if (branch->TestBit(kDoNotProcess)) continue;
TString name = branch->GetName();
if (name.Contains("fBits") || name.Contains("fUniqueID")) continue;
// now map sub-branches
MapBranch(branch, fr->GetName(), parent, listIt);
fStopMapping = kFALSE;
}
}
// tell who was last mapped
if (listIt) {
fMappedTree = tree;
fMappedBranch = 0;
}
}
//______________________________________________________________________________
void TTreeViewer::MapBranch(TBranch *branch, const char *prefix, TGListTreeItem *parent, Bool_t listIt)
{
// Map current branch and expand its content in the list view.
if (!branch) return;
TString name;
if (prefix && strlen(prefix) >0) name = Form("%s.%s",prefix,branch->GetName());
else name = branch->GetName();
Int_t ind;
TGListTreeItem *branchItem = 0;
ULong_t *itemType;
// map this branch
if (name.Contains("fBits") || name.Contains("fUniqueID")) return;
if (parent) {
// make list tree items for each branch according to the type
const TGPicture *pic, *spic;
if ((branch->GetListOfBranches()->GetEntries()) ||
(branch->GetNleaves())) {
if (branch->GetListOfBranches()->GetEntries()) {
itemType = new ULong_t(kLTBranchType);
if (branch->InheritsFrom("TBranchObject")) {
pic = gClient->GetPicture("branch-ob_t.xpm");
spic = gClient->GetPicture("branch-ob_t.xpm");
} else {
if (branch->InheritsFrom("TBranchClones")) {
pic = gClient->GetPicture("branch-cl_t.xpm");
spic = gClient->GetPicture("branch-cl_t.xpm");
} else {
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
}
}
branchItem = fLt->AddItem(parent, EmptyBrackets(name), itemType, pic, spic);
} else {
if (branch->GetNleaves() > 1) {
itemType = new ULong_t(kLTBranchType);
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
branchItem = fLt->AddItem(parent, EmptyBrackets(name), itemType,pic, spic);
TObjArray *leaves = branch->GetListOfLeaves();
TLeaf *leaf = 0;
TString leafName;
for (Int_t lf=0; lf<leaves->GetEntries(); lf++) {
leaf = (TLeaf *)leaves->At(lf);
leafName = name;
leafName.Append(".").Append(EmptyBrackets(leaf->GetName()));
itemType = new ULong_t(kLTLeafType);
pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetPicture("leaf_t.xpm");
fLt->AddItem(branchItem, leafName.Data(), itemType, pic, spic);
}
} else {
itemType = new ULong_t(kLTLeafType);
pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetPicture("leaf_t.xpm");
branchItem = fLt->AddItem(parent, EmptyBrackets(name), itemType, pic, spic);
}
}
}
}
// list branch in list view if necessary
if (listIt) {
TGString *textEntry;
const TGPicture *pic, *spic;
TTVLVEntry *entry;
// make list view items in the right frame
if (!fStopMapping) {
fMappedBranch = branch;
fMappedTree = 0;
fStopMapping = kTRUE;
}
textEntry = new TGString(EmptyBrackets(name.Data()));
if ((branch->GetListOfBranches()->GetEntries()) ||
(branch->GetNleaves())) {
if (branch->GetListOfBranches()->GetEntries()) {
if (branch->InheritsFrom("TBranchObject")) {
pic = gClient->GetPicture("branch-ob_t.xpm");
spic = gClient->GetPicture("branch-ob_t.xpm");
} else {
if (branch->InheritsFrom("TBranchClones")) {
pic = gClient->GetPicture("branch-cl_t.xpm");
spic = gClient->GetPicture("branch-cl_t.xpm");
} else {
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
}
}
entry = new TTVLVEntry(fLVContainer,pic,spic,textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTBranchType));
entry->SetToolTipText("Branch with sub-branches. Can not be dragged");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
} else {
if (branch->GetNleaves() > 1) {
if (textEntry) delete textEntry;
textEntry = new TGString(EmptyBrackets(name.Data()));
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
entry = new TTVLVEntry(fLVContainer, pic, spic, textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTBranchType));
entry->SetToolTipText("Branch with more than one leaf. Can not be dragged");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
TObjArray *leaves = branch->GetListOfLeaves();
TLeaf *leaf = 0;
TString leafName;
for (Int_t lf=0; lf<leaves->GetEntries(); lf++) {
leaf = (TLeaf *)leaves->At(lf);
leafName = name;
leafName.Append(".").Append(EmptyBrackets(leaf->GetName()));
textEntry = new TGString(leafName.Data());
pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetPicture("leaf_t.xpm");
entry = new TTVLVEntry(fLVContainer, pic, spic, textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTDragType | kLTLeafType));
entry->SetToolTipText("Double-click to draw. Drag to X, Y, Z or scan box.");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
}
} else {
pic = (gClient->GetMimeTypeList())->GetIcon("TLeaf",kFALSE);
if (!pic) pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetMimeTypeList()->GetIcon("TLeaf",kTRUE);
if (!spic) spic = gClient->GetPicture("leaf_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTDragType | kLTLeafType));
entry->SetToolTipText("Double-click to draw. Drag to X, Y, Z or scan box.");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
}
}
}
}
TObjArray *branches = branch->GetListOfBranches();
TBranch *branchDaughter = 0;
// loop all sub-branches
for (ind=0; ind<branches->GetEntries(); ind++) {
branchDaughter = (TBranch *)branches->UncheckedAt(ind);
// map also all sub-branches
MapBranch(branchDaughter, "", branchItem, listIt);
}
}
//______________________________________________________________________________
void TTreeViewer::NewExpression()
{
// Create new expression
fLVContainer->RemoveNonStatic();
const TGPicture *pic = gClient->GetPicture("expression_t.xpm");
const TGPicture *spic = gClient->GetPicture("expression_t.xpm");
TTVLVEntry *entry = new TTVLVEntry(fLVContainer,pic,spic,
new TGString(),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTDragType));
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->Empty();
if (fMappedTree) MapTree(fTree);
if (fMappedBranch) MapBranch(fMappedBranch);
fListView->Layout();
fNexpressions++;
}
//______________________________________________________________________________
void TTreeViewer::SetParentTree(TGListTreeItem *item)
{
// Find parent tree of a clicked item.
if (!item) return;
ULong_t *itemType = (ULong_t *)item->GetUserData();
TGListTreeItem *parent = 0;
Int_t index;
if (!(*itemType & kLTTreeType)) {
parent = item->GetParent();
SetParentTree(parent);
} else {
index = (Int_t)(*itemType >> 8);
SwitchTree(index);
}
}
//______________________________________________________________________________
void TTreeViewer::Message(const char* msg)
{
// Send a message on the status bar.
fStatusBar->SetText(msg);
}
//______________________________________________________________________________
void TTreeViewer::DoError(int level, const char *location, const char *fmt, va_list va) const
{
// Put error/warning into TMsgBox and also forward to console.
TObject::DoError(level, location, fmt, va);
// in case level will abort we will not come here...
static const int buf_size = 2048;
char buf[buf_size], *bp;
int n = vsnprintf(buf, buf_size, fmt, va);
// old vsnprintf's return -1 if string is truncated new ones return
// total number of characters that would have been written
if (n == -1 || n >= buf_size) {
TObject::Warning("DoError", "Error message string truncated...");
}
if (level >= kSysError && level < kFatal)
bp = Form("%s (%s)", buf, gSystem->GetError());
else
bp = buf;
const char *title = "";
if (level == kInfo)
title = "Info";
if (level == kWarning)
title = "Warning";
if (level == kError)
title = "Error";
if (level == kSysError)
title = "System Error";
new TGMsgBox(fClient->GetRoot(), this, title, bp, kMBIconExclamation);
}
//______________________________________________________________________________
void TTreeViewer::PrintEntries()
{
// Print the number of selected entries on status-bar.
if (!fTree) return;
char * msg = new char[100];
sprintf(msg, "First entry : %lld Last entry : %lld",
(Long64_t)fSlider->GetMinPosition(), (Long64_t)fSlider->GetMaxPosition());
Message(msg);
delete[] msg;
}
//______________________________________________________________________________
void TTreeViewer::SaveSource(const char* filename, Option_t *)
{
// Save current session as a C++ macro file.
if (!fTree) return;
char quote = '"';
ofstream out;
Int_t lenfile = strlen(filename);
char * fname;
if (!lenfile) {
fname = (char*)fSourceFile;
lenfile = strlen(fname);
} else {
fname = (char*)filename;
fSourceFile = filename;
}
// if filename is given, open this file, otherwise create a file
// with a name : treeviewer.C
if (lenfile) {
out.open(fname, ios::out);
} else {
fname = new char[13];
strcpy(fname, "treeviewer.C");
out.open(fname, ios::out);
}
if (!out.good ()) {
printf("SaveSource cannot open file : %s\n", fname);
fSourceFile = "treeviewer.C";
if (!lenfile) delete [] fname;
return;
}
// Write macro header and date/time stamp
TDatime t;
TString sname(fname);
sname = sname.ReplaceAll(".C", "");
out <<"void "<<sname.Data()<<"() {"<<endl;
out <<"//=========Macro generated by ROOT version"<<gROOT->GetVersion()<<endl;
out <<"//=========for tree "<<quote<<fTree->GetName()<<quote<<" ("<<t.AsString()<<")"<<endl;
out <<"//===This macro can be opened from a TreeViewer session after loading"<<endl;
out <<"//===the corresponding tree, or by running root with the macro name argument"<<endl<<endl;
out <<" open_session();"<<endl;
out <<"}"<<endl<<endl;
out <<"open_session(void *p = 0) {"<<endl;
out <<" gSystem->Load("<<quote<<"libTreeViewer"<<quote<<");"<<endl;
out <<" TTreeViewer *treeview = (TTreeViewer *) p;"<<endl;
out <<" if (!treeview) treeview = new TTreeViewer();"<<endl;
out <<" TTree *tv_tree = (TTree*)gROOT->FindObject("<<quote<<fTree->GetName()<<quote<<");"<<endl;
out <<" TFile *tv_file = (TFile*)gROOT->GetListOfFiles()->FindObject("<<quote<<fFilename<<quote<<");"<<endl;
out <<" if (!tv_tree) {"<<endl;
out <<" if (!tv_file) tv_file = new TFile("<<quote<<fFilename<<quote<<");"<<endl;
out <<" if (tv_file) tv_tree = (TTree*)tv_file->Get("<<quote<<fTree->GetName()<<quote<<");"<<endl;
out <<" if(!tv_tree) {"<<endl;
out <<" printf(\"Tree %s not found\", fTree->GetName());"<<endl;
out <<" return;"<<endl;
out <<" }"<<endl;
out <<" }"<<endl<<endl;
out <<" treeview->SetTreeName("<<quote<<fTree->GetName()<<quote<<");"<<endl;
out <<" treeview->SetNexpressions("<<fNexpressions<<");"<<endl;
// get expressions
TTVLVEntry *item;
out <<"// Set expressions on axis and cut"<<endl;
out <<" TTVLVEntry *item;"<<endl;
for (Int_t i=0; i<4; i++) {
switch (i) {
case 0:
out <<"// X expression"<<endl;
break;
case 1:
out <<"// Y expression"<<endl;
break;
case 2:
out <<"// Z expression"<<endl;
break;
case 3:
out <<"// Cut expression"<<endl;
break;
default:
break;
}
item = ExpressionItem(i);
out <<" item = treeview->ExpressionItem("<<i<<");"<<endl;
out <<" item->SetExpression("<<quote<<item->GetTrueName()<<quote
<<", "<<quote<<item->GetAlias()<<quote<<");"<<endl;
}
out <<"// Scan list"<<endl;
item = ExpressionItem(4);
out <<" item = treeview->ExpressionItem(4);"<<endl;
out <<" item->SetExpression("<<quote<<item->GetTrueName()<<quote
<<", "<<quote<<"Scan box"<<quote<<");"<<endl;
out <<"// User defined expressions"<<endl;
TString itemType;
for (Int_t crt=5; crt<fNexpressions+5; crt++) {
item = ExpressionItem(crt);
if (item->IsCut())
itemType = "kTRUE";
else
itemType = "kFALSE";
out <<" item = treeview->ExpressionItem("<<crt<<");"<<endl;
out <<" item->SetExpression("<<quote<<item->GetTrueName()<<quote
<<", "<<quote<<item->GetAlias()<<quote<<", "<<itemType.Data()<<");"<<endl;
}
fSession->SaveSource(out);
out <<"}"<<endl;
out.close();
printf("C++ Macro file: %s has been generated\n", fname);
if (!lenfile) delete [] fname;
}
//______________________________________________________________________________
Bool_t TTreeViewer::SwitchTree(Int_t index)
{
// Makes current the tree at a given index in the list.
TTree *tree = (TTree *) fTreeList->At(index);
if (!tree) {
Warning("SwitchTree", "No tree found.");
return kFALSE;
}
if ((tree == fTree) && (tree == fMappedTree)) return kFALSE; // nothing to switch
std::string command;
if (tree != fTree) {
command = "tv__tree = (TTree *) tv__tree_list->At";
command += Form("(%i)",index);
ExecuteCommand(command.c_str());
}
fTree = tree;
fSlider->SetRange(0,fTree->GetEntries()-1);
fSlider->SetPosition(0,fTree->GetEntries()-1);
command = "Current Tree : ";
command += fTree->GetName();
fLbl2->SetText(new TGString(command.c_str()));
fTreeHdr->Layout();
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
///Resize(); //ia
PrintEntries();
return kTRUE;
}
//______________________________________________________________________________
void TTreeViewer::SetRecordName(const char *name)
{
// Set record name
fSession->SetRecordName(name);
}
//______________________________________________________________________________
void TTreeViewer::SetCurrentRecord(Long64_t entry)
{
// Set current record
fCombo->Select(entry);
}
//______________________________________________________________________________
void TTreeViewer::SetHistogramTitle(const char *title)
{
// Set title of Histogram
if (!gPad) return;
TH1 *hist = (TH1*)gPad->GetListOfPrimitives()->FindObject(fBarHist->GetText());
if (hist) {
hist->SetTitle(title);
gPad->Update();
}
}
//______________________________________________________________________________
void TTreeViewer::SetUserCode(const char *code, Bool_t autoexec)
{
// user defined command for current record
TTVRecord *rec = fSession->GetCurrent();
if (rec) rec->SetUserCode(code, autoexec);
}
//______________________________________________________________________________
void TTreeViewer::UpdateCombo()
{
// Updates combo box to current session entries.
fCombo->RemoveEntries(0, 1000);
for (Long64_t entry=0; entry<fSession->GetEntries(); entry++) {
fCombo->AddEntry(fSession->GetRecord(entry)->GetName(), entry);
}
}
//______________________________________________________________________________
void TTreeViewer::UpdateRecord(const char *name)
{
// Updates current record to new X, Y, Z items.
fSession->UpdateRecord(name);
}
//______________________________________________________________________________
void TTreeViewer::DoRefresh()
{
// This slot is called when button REFR is clicked
fTree->Refresh();
Float_t min = fSlider->GetMinPosition();
Float_t max = (Float_t)fTree->GetEntries()-1;
fSlider->SetRange(min,max);
fSlider->SetPosition(min,max);
ExecuteDraw();
}
Fix potential resource leak (coverity)
git-svn-id: acec3fd5b7ea1eb9e79d6329d318e8118ee2e14f@35316 27541ba8-7e3a-0410-8455-c3a389f83636
// @(#)root/treeviewer:$Id$
//Author : Andrei Gheata 16/08/00
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
//////////////////////////////////////////////////////////////////////////
//
// TreeViewer is a graphic user interface designed to handle ROOT trees and to
// take advantage of TTree class features.
//
// It uses ROOT native GUI widgets adapted for 'drag and drop' functionality.
// in the same session.
// The following capabilities are making the viewer a helpful tool for analysis:
// - several trees may be opened in the same session;
// - branches and leaves can be easily browsed or scanned;
// - fast drawing of branch expressions by double-clicking;
// - new variables/selections easy to compose with the built-in editor;
// - histograms can be composed by dragging leaves or user-defined expressions
// to X, Y and Z axis items;
// - the tree entries to be processed can be selected with a double slider;
// - selections can be defined and activated by dragging them to the 'Cut' item;
// - all expressions can be aliased and aliases can be used in composing others;
// - input/output event lists easy to handle;
// - menu with histogram drawing options;
// - user commands may be executed within the viewer and the current command
// can be echoed;
// - current 'Draw' event loop is reflected by a progress bar and may be
// interrupted by the user;
// - all widgets have self-explaining tool tips and/or context menus;
// - expressions/leaves can be dragged to a 'scan box' and scanned by
// double-clicking this item. The result can be redirected to an ASCII file;
//
// The layout has the following items:
//
// - a menu bar with entries : File, Edit, Run, Options and Help;
// - a toolbar in the upper part where you can issue user commands, change
// the drawing option and the histogram name, three check buttons Hist, Rec
// and Scan.HIST toggles histogram drawing mode, REC enables recording of the
// last command issued and SCAN enables redirecting of TTree::Scan command in
// an ASCII file (see -Scanning expressions-);
// - a button bar in the lower part with : buttons DRAW/STOP that issue histogram
// drawing and stop the current command respectively, two text widgets where
// input and output event lists can be specified, a message box and a RESET
// button on the right that clear edited expression content (see Editing...)
// - a tree-type list on the main left panel where you can select among trees or
// branches. The tree/branch will be detailed in the right panel.
// Mapped trees are provided with context menus, activated by right-clicking;
// - a view-type list on the right panel. The first column contain X, Y and
// Z expression items, an optional cut and ten optional editable expressions.
// Expressions and leaf-type items can be dragged or deleted. A right click on
// the list-box or item activates context menus.
//
// Opening a new tree and saving a session :
//
// To open a new tree in the viewer use <File/Open tree file> menu
// The content of the file (keys) will be listed. Use <SetTreeName> function
// from the context menu of the right panel, entering a tree name among those
// listed.
// To save the current session, use <File/Save> menu or the <SaveSource>
// function from the context menu of the right panel (to specify the name of the
// file - name.C)
// To open a previously saved session for the tree MyTree, first open MyTree
// in the browser, then use <File/Open session> menu.
//
// Dragging items:
//
// Items that can be dragged from the list in the right : expressions and
// leaves. Dragging an item and dropping to another will copy the content of first
// to the last (leaf->expression, expression->expression). Items far to the right
// side of the list can be easily dragged to the left (where expressions are
// placed) by dragging them to the left at least 10 pixels.
//
// Editing expressions
//
// Any editable expression from the right panel has two components : a
// true name (that will be used when TTree::Draw() commands are issued) and an
// alias. The visible name is the alias. Aliases of user defined expressions have
// a leading ~ and may be used in new expressions. Expressions containing boolean
// operators have a specific icon and may be dragged to the active cut (scissors
// item) position.
// The expression editor can be activated by double-clicking empty expression,
// using <EditExpression> from the selected expression context menu or using
// <Edit/Expression> menu.
// The editor will pop-up in the left part, but it can be moved.
// The editor usage is the following :
// - you can write C expressions made of leaf names by hand or you can insert
// any item from the right panel by clicking on it (recommandable);
// - you can click on other expressions/leaves to paste them in the editor;
// - you should write the item alias by hand since it not only make the expression
// meaningfull, but it also highly improve the layout for big expressions
// - you may redefine an old alias - the other expressions depending on it will
// be modified accordingly. An alias must not be the leading string of other aliases.
// When Draw commands are issued, the name of the corresponding histogram axes
// will become the aliases of the expressions.
//
// User commands can be issued directly from the textbox labeled "Command"
// from the upper-left toolbar by typing and pressing Enter at the end.
// An other way is from the right panel context menu : ExecuteCommand.
// All commands can be interrupted at any time by pressing the STOP button
// from the bottom-left
// You can toggle recording of the current command in the history file by
// checking the Rec button from the top-right
//
// Context menus
//
// You can activate context menus by right-clicking on items or inside the
// right panel.
// Context menus for mapped items from the left tree-type list :
// The items from the left that are provided with context menus are tree and
// branch items. You can directly activate the *MENU* marked methods of TTree
// from this menu.
// Context menu for the right panel :
// A general context menu is acivated if the user right-clicks the right panel.
// Commands are :
// - EmptyAll : clears the content of all expressions;
// - ExecuteCommand : execute a ROOT command;
// - MakeSelector : equivalent of TTree::MakeSelector();
// - NewExpression : add an expression item in the right panel;
// - Process : equivalent of TTree::Process();
// - SaveSource : save the current session as a C++ macro;
// - SetScanFileName : define a name for the file where TTree::Scan command
// is redirected when the <Scan> button is checked;
// - SetTreeName : open a new tree whith this name in the viewer;
// A specific context menu is activated if expressions/leaves are right-clicked.
// Commands are :
// - Draw : draw a histogram for this item;
// - EditExpression : pops-up the expression editor;
// - Empty : empty the name and alias of this item;
// - RemoveItem : removes clicked item from the list;
// - Scan : scan this expression;
// - SetExpression : edit name and alias for this item by hand;
//
// Starting the viewer
//
// 1) From the TBrowser :
// Select a tree in the TBrowser, then call the StartViewer() method from its
// context menu (right-click on the tree).
// 2) From the command line :
// Start a ROOT session in the directory where you have your tree.
// You will need first to load the library for TTreeViewer and optionally other
// libraries for user defined classes (you can do this later in the session) :
// root [0] gSystem->Load(\"TTreeViewer\");
// Supposing you have the tree MyTree in the file MyFile, you can do :
// root [1] TFile file(\"Myfile\");
// root [2] new TTreeViewer(\"Mytree\");
// or :
// root [2] TreeViewer *tv = new TTreeViewer();
// root [3] tv->SetTreeName(\"Mytree\");
//
//Begin_Html
/*
<img src="treeview.gif">
*/
//End_Html
//
#include "RConfigure.h"
#include "snprintf.h"
#include "Riostream.h"
#include "TTreeViewer.h"
#include "HelpText.h"
#include "HelpTextTV.h"
#include "TTVLVContainer.h"
#include "TTVSession.h"
#include "TROOT.h"
#include "TError.h"
#include "TGMsgBox.h"
#include "TTreePlayer.h"
#include "TContextMenu.h"
#include "TInterpreter.h"
#include "TLeaf.h"
#include "TRootHelpDialog.h"
#include "TSystem.h"
#include "TApplication.h"
#include "TVirtualX.h"
#include "TGClient.h"
#include "TKey.h"
#include "TFile.h"
#include "TGMenu.h"
#include "TGFrame.h"
#include "TCanvas.h"
#include "TH1.h"
#include "TTree.h"
#include "TFriendElement.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TGButton.h"
#include "TGButtonGroup.h"
#include "TGTextEntry.h"
#include "TGComboBox.h"
#include "TGLabel.h"
#include "TGListView.h"
#include "TGListTree.h"
#include "TGMimeTypes.h"
#include "TGSplitter.h"
#include "TGDoubleSlider.h"
#include "TGToolBar.h"
#include "TGStatusBar.h"
#include "Getline.h"
#include "TTimer.h"
#include "TG3DLine.h"
#include "TGFileDialog.h"
#include "TGProgressBar.h"
#include "TClonesArray.h"
#include "TSpider.h"
#ifdef WIN32
#include "TWin32SplashThread.h"
#endif
// drawing options
static const char* gOptgen[16] =
{
"","AXIS","HIST","SAME","CYL","POL","SPH","PSR","LEGO","LEGO1","LEGO2",
"SURF","SURF1","SURF2","SURF3","SURF4"
};
static const char* gOpt1D[12] =
{
"","AH","B","C","E","E1","E2","E3","E4","L","P","*H"
};
static const char* gOpt2D[14] =
{
"","ARR","BOX","COL","COL2","CONT","CONT0","CONT1","CONT2","CONT3",
"FB","BB","SCAT","PROF"
};
static const char* gOpenTypes[] = {"Root files", "*.root",
0, 0 };
static const char* gMacroTypes[] = {"C++ macros", "*.C",
0, 0 };
// Menu command id's
enum ERootTreeViewerCommands {
kFileCanvas,
kFileBrowse,
kFileLoadLibrary = 3,
kFileOpenSession,
kFileSaveMacro,
kFilePrint,
kFileClose,
kFileQuit,
kEditExpression,
kEditCut,
kEditMacro,
kEditEvent,
kRunCommand,
kRunMacro,
kOptionsReset,
kOptionsGeneral = 20,
kOptions1D = 50,
kOptions2D = 70,
kHelpAbout = 100,
kHelpAboutTV,
kHelpStart,
kHelpLayout,
kHelpOpenSave,
kHelpDragging,
kHelpEditing,
kHelpSession,
kHelpCommands,
kHelpContext,
kHelpDrawing,
kHelpMacros,
kBarCommand,
kBarOption,
kBarCut,
kAxis
};
// button Id's
enum EButtonIdentifiers {
kDRAW,
kRESET,
kSTOP,
kCLOSE,
kSLIDER,
kBGFirst,
kBGPrevious,
kBGRecord,
kBGNext,
kBGLast
};
ClassImp(TTreeViewer)
//______________________________________________________________________________
TTreeViewer::TTreeViewer(const char* treeName) :
TGMainFrame(0,10,10,kVerticalFrame),
fDimension(0), fVarDraw(0), fScanMode(0),
fTreeIndex(0), fDefaultCursor(0), fWatchCursor(0),
fCounting(0), fStopMapping(0), fEnableCut(0),fNexpressions(0)
{
// TTreeViewer default constructor
fTree = 0;
if (!gClient) return;
char command[128];
sprintf(command, "TTreeViewer *gTV = (TTreeViewer*)0x%lx", (ULong_t)this);
gROOT->ProcessLine(command);
gROOT->ProcessLine("TTree *tv__tree = 0;");
fTreeList = new TList;
gROOT->ProcessLine("TList *tv__tree_list = new TList;");
fFilename = "";
gROOT->ProcessLine("TFile *tv__tree_file = 0;");
gInterpreter->SaveContext();
BuildInterface();
SetTreeName(treeName);
}
//______________________________________________________________________________
TTreeViewer::TTreeViewer(const TTree *tree) :
TGMainFrame(0, 10, 10, kVerticalFrame),
fDimension(0), fVarDraw(0), fScanMode(0),
fTreeIndex(0), fDefaultCursor(0), fWatchCursor(0),
fCounting(0), fStopMapping(0), fEnableCut(0),fNexpressions(0)
{
// TTreeViewer constructor with a pointer to a Tree
fTree = 0;
char command[128];
sprintf(command, "TTreeViewer *gTV = (TTreeViewer*)0x%lx", (ULong_t)this);
gROOT->ProcessLine(command);
if (!tree) return;
gROOT->ProcessLine("TTree *tv__tree = 0;");
fTreeList = new TList;
gROOT->ProcessLine("TList *tv__tree_list = new TList;");
fFilename = "";
gROOT->ProcessLine("TFile *tv__tree_file = 0;");
gInterpreter->SaveContext();
BuildInterface();
TDirectory *dirsav = gDirectory;
TDirectory *cdir = tree->GetDirectory();
if (cdir) cdir->cd();
SetTreeName(tree->GetName());
// If the tree is a chain, the tree directory will be changed by SwitchTree
// (called by SetTreeName)
cdir = tree->GetDirectory();
if (cdir) {
if (cdir->GetFile()) fFilename = cdir->GetFile()->GetName();
}
if (dirsav) dirsav->cd();
}
//______________________________________________________________________________
void TTreeViewer::AppendTree(TTree *tree)
{
// Allow geting the tree from the context menu.
if (!tree) return;
TTree *ftree;
if (fTreeList) {
if (fTreeList->FindObject(tree)) {
printf("Tree found\n");
TIter next(fTreeList);
Int_t index = 0;
while ((ftree = (TTree*)next())) {
if (ftree==tree) {printf("found at index %i\n", index);break;}
index++;
}
SwitchTree(index);
if (fTree != fMappedTree) {
// switch also the global "tree" variable
fLVContainer->RemoveNonStatic();
// map it on the right panel
MapTree(fTree);
fListView->Layout();
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
TGListTreeItem *item = fLt->FindChildByName(parent, fTree->GetName());
fLt->ClearHighlighted();
fLt->HighlightItem(item);
fClient->NeedRedraw(fLt);
}
return;
}
}
if (fTree != tree) {
fTree = tree;
// load the tree via the interpreter
char command[100];
command[0] = 0;
// define a global "tree" variable for the same tree
sprintf(command, "tv__tree = (TTree *)0x%lx;", (ULong_t)tree);
ExecuteCommand(command);
}
//--- add the tree to the list if it is not already in
if (fTreeList) fTreeList->Add(fTree);
ExecuteCommand("tv__tree_list->Add(tv__tree);");
//--- map this tree
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
if (!parent) parent = fLt->AddItem(base, "TreeList", new ULong_t(kLTNoType));
ULong_t *itemType = new ULong_t((fTreeIndex << 8) | kLTTreeType);
fTreeIndex++;
TGListTreeItem *lTreeItem = fLt->AddItem(parent, tree->GetName(), itemType,
gClient->GetPicture("tree_t.xpm"), gClient->GetPicture("tree_t.xpm"));
MapTree(fTree, lTreeItem, kFALSE);
fLt->OpenItem(parent);
fLt->HighlightItem(lTreeItem);
fClient->NeedRedraw(fLt);
//--- map slider and list view
SwitchTree(fTreeIndex-1);
fLVContainer->RemoveNonStatic();
MapTree(fTree);
fListView->Layout();
SetFile();
}
//______________________________________________________________________________
void TTreeViewer::SetNexpressions(Int_t expr)
{
// Change the number of expression widgets.
Int_t diff = expr - fNexpressions;
if (diff <= 0) return;
if (!fLVContainer) return;
for (Int_t i=0; i<TMath::Abs(diff); i++) NewExpression();
}
//______________________________________________________________________________
void TTreeViewer::SetScanFileName(const char *name)
{
// Set the name of the file where to redirect <Scan> output.
if (fTree) ((TTreePlayer *)fTree->GetPlayer())->SetScanFileName(name);
}
//______________________________________________________________________________
void TTreeViewer::SetScanRedirect(Bool_t mode)
{
// Set the state of Scan check button.
if (mode)
fBarScan->SetState(kButtonDown);
else
fBarScan->SetState(kButtonUp);
}
//______________________________________________________________________________
void TTreeViewer::SetTreeName(const char* treeName)
{
// Allow geting the tree from the context menu.
if (!treeName) return;
TTree *tree = (TTree *) gROOT->FindObject(treeName);
if (fTreeList) {
if (fTreeList->FindObject(treeName)) {
printf("Tree found\n");
TIter next(fTreeList);
Int_t index = 0;
while ((tree = (TTree*)next())) {
if (!strcmp(treeName, tree->GetName())) {printf("found at index %i\n", index);break;}
index++;
}
SwitchTree(index);
if (fTree != fMappedTree) {
// switch also the global "tree" variable
fLVContainer->RemoveNonStatic();
// map it on the right panel
MapTree(fTree);
fListView->Layout();
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
TGListTreeItem *item = fLt->FindChildByName(parent, fTree->GetName());
fLt->ClearHighlighted();
fLt->HighlightItem(item);
fClient->NeedRedraw(fLt);
}
return;
}
}
if (!tree) return;
// ((TTreePlayer *)tree->GetPlayer())->SetViewer(this);
if (fTree != tree) {
fTree = tree;
// load the tree via the interpreter
// define a global "tree" variable for the same tree
TString command = TString::Format("tv__tree = (TTree *) gROOT->FindObject(\"%s\");", treeName);
ExecuteCommand(command.Data());
}
//--- add the tree to the list if it is not already in
if (fTreeList) fTreeList->Add(fTree);
ExecuteCommand("tv__tree_list->Add(tv__tree);");
//--- map this tree
TGListTreeItem *base = 0;
TGListTreeItem *parent = fLt->FindChildByName(base, "TreeList");
if (!parent) parent = fLt->AddItem(base, "TreeList", new ULong_t(kLTNoType));
ULong_t *itemType = new ULong_t((fTreeIndex << 8) | kLTTreeType);
fTreeIndex++;
TGListTreeItem *lTreeItem = fLt->AddItem(parent, treeName, itemType,
gClient->GetPicture("tree_t.xpm"), gClient->GetPicture("tree_t.xpm"));
MapTree(fTree, lTreeItem, kFALSE);
fLt->OpenItem(parent);
fLt->HighlightItem(lTreeItem);
fClient->NeedRedraw(fLt);
//--- map slider and list view
SwitchTree(fTreeIndex-1);
fLVContainer->RemoveNonStatic();
MapTree(fTree);
fListView->Layout();
SetFile();
}
//______________________________________________________________________________
void TTreeViewer::SetFile()
{
// Set file name containing the tree.
if (!fTree) return;
TSeqCollection *list = gROOT->GetListOfFiles();
TTree *tree;
TIter next(list);
TObject *obj;
TFile *file;
while ((obj=next())) {
file = (TFile*)obj;
if (file) {
tree = (TTree*)file->Get(fTree->GetName());
if (tree) {
fFilename = file->GetName();
cout << "File name : "<< fFilename << endl;
return;
} else {
fFilename = "";
}
}
}
fFilename = "";
}
//______________________________________________________________________________
void TTreeViewer::BuildInterface()
{
// Create all viewer widgets.
//--- timer & misc
fCounting = kFALSE;
fScanMode = kFALSE;
fEnableCut = kTRUE;
fTimer = new TTimer(this, 20, kTRUE);
fLastOption = "";
fSession = new TTVSession(this);
//--- cursors
fDefaultCursor = gVirtualX->CreateCursor(kPointer);
fWatchCursor = gVirtualX->CreateCursor(kWatch);
//--- colours
ULong_t color;
gClient->GetColorByName("blue",color);
//--- pictures for X, Y and Z expression items
fPicX = gClient->GetPicture("x_pic.xpm");
fPicY = gClient->GetPicture("y_pic.xpm");
fPicZ = gClient->GetPicture("z_pic.xpm");
//--- general context menu
fContextMenu = new TContextMenu("TreeViewer context menu","");
fMappedTree = 0;
fMappedBranch = 0;
fDialogBox = 0;
fDimension = 0;
fVarDraw = kFALSE;
fStopMapping = kFALSE;
// fFilename = "";
fSourceFile = "treeviewer.C";
//--- lists : trees and widgets to be removed
// fTreeList = 0;
fTreeIndex = 0;
fWidgets = new TList();
//--- create menus --------------------------------------------------------
//--- File menu
fFileMenu = new TGPopupMenu(fClient->GetRoot());
fFileMenu->AddEntry("&New canvas", kFileCanvas);
fFileMenu->AddEntry("Open &tree file...", kFileBrowse);
fFileMenu->AddEntry("&Load Library...", kFileLoadLibrary);
fFileMenu->AddEntry("&Open session", kFileOpenSession);
fFileMenu->AddEntry("&Save source", kFileSaveMacro);
fFileMenu->AddSeparator();
fFileMenu->AddEntry("&Print", kFilePrint);
fFileMenu->AddEntry("&Close", kFileClose);
fFileMenu->AddSeparator();
fFileMenu->AddEntry("&Quit ROOT", kFileQuit);
fFileMenu->DisableEntry(kFilePrint);
//--- Edit menu
fEditMenu = new TGPopupMenu(gClient->GetRoot());
fEditMenu->AddEntry("&Expression...", kEditExpression);
fEditMenu->AddEntry("&Cut...", kEditCut);
fEditMenu->AddEntry("&Macro...", kEditMacro);
fEditMenu->AddEntry("E&Vent...", kEditEvent);
fEditMenu->DisableEntry(kEditMacro);
fEditMenu->DisableEntry(kEditEvent);
//---Run menu
fRunMenu = new TGPopupMenu(gClient->GetRoot());
fRunMenu->AddEntry("&Macro...", kRunMacro);
fRunMenu->DisableEntry(kRunMacro);
//--- Options menu
//--- General options
fOptionsGen = new TGPopupMenu(gClient->GetRoot());
fOptionsGen->AddEntry("Default", kOptionsGeneral);
fOptionsGen->AddSeparator();
fOptionsGen->AddEntry("Axis only", kOptionsGeneral+1); // "AXIS"
fOptionsGen->AddEntry("Contour only", kOptionsGeneral+2); // "HIST"
fOptionsGen->AddEntry("Superimpose", kOptionsGeneral+3); //"SAME"
fOptionsGen->AddEntry("Cylindrical", kOptionsGeneral+4); //"CYL"
fOptionsGen->AddEntry("Polar", kOptionsGeneral+5); //"POL"
fOptionsGen->AddEntry("Spherical", kOptionsGeneral+6); //"SPH"
fOptionsGen->AddEntry("PsRap/Phi", kOptionsGeneral+7); //"PSR"
fOptionsGen->AddEntry("Lego HLR", kOptionsGeneral+8); //"LEGO"
fOptionsGen->AddEntry("Lego HSR", kOptionsGeneral+9); //"LEGO1"
fOptionsGen->AddEntry("Lego Color", kOptionsGeneral+10); //"LEGO2"
fOptionsGen->AddEntry("Surface HLR", kOptionsGeneral+11); //"SURF"
fOptionsGen->AddEntry("Surface HSR", kOptionsGeneral+12); //"SURF1"
fOptionsGen->AddEntry("Surface Col", kOptionsGeneral+13); //"SURF2"
fOptionsGen->AddEntry("Surf+Cont", kOptionsGeneral+14); //"SURF3"
fOptionsGen->AddEntry("Gouraud", kOptionsGeneral+15); //"SURF4"
fOptionsGen->Associate(this);
//--- 1D options
fOptions1D = new TGPopupMenu(gClient->GetRoot());
fOptions1D->AddEntry("Default", kOptions1D);
fOptions1D->AddSeparator();
fOptions1D->AddEntry("No labels/ticks", kOptions1D+1); // "AH"
fOptions1D->AddEntry("Bar chart", kOptions1D+2); // "B"
fOptions1D->AddEntry("Smooth curve", kOptions1D+3); // "C"
fOptions1D->AddEntry("Errors", kOptions1D+4); // "E"
fOptions1D->AddEntry("Errors 1", kOptions1D+5); // "E1"
fOptions1D->AddEntry("Errors 2", kOptions1D+6); // "E2"
fOptions1D->AddEntry("Errors 3", kOptions1D+7); // "E3"
fOptions1D->AddEntry("Errors 4", kOptions1D+8); // "E4"
fOptions1D->AddEntry("Line", kOptions1D+9); // "L"
fOptions1D->AddEntry("Markers", kOptions1D+10); // "P"
fOptions1D->AddEntry("Stars", kOptions1D+11); // "*H"
fOptions1D->Associate(this);
//--- 2D options
fOptions2D = new TGPopupMenu(gClient->GetRoot());
fOptions2D->AddEntry("Default", kOptions2D);
fOptions2D->AddSeparator();
fOptions2D->AddEntry("Arrows", kOptions2D+1); // "ARR"
fOptions2D->AddEntry("Box/Surf", kOptions2D+2); // "BOX"
fOptions2D->AddEntry("Box/Color", kOptions2D+3); // "COL"
fOptions2D->AddEntry("Box/ColMap", kOptions2D+4); // "COLZ"
fOptions2D->AddEntry("Contour", kOptions2D+5); // "CONT"
fOptions2D->AddEntry("Contour 0", kOptions2D+6); // "CONT0"
fOptions2D->AddEntry("Contour 1", kOptions2D+7); // "CONT1"
fOptions2D->AddEntry("Contour 2", kOptions2D+8); // "CONT2"
fOptions2D->AddEntry("Contour 3", kOptions2D+9); // "CONT3"
fOptions2D->AddEntry("No front-box", kOptions2D+10); // "FB"
fOptions2D->AddEntry("No back-box", kOptions2D+11); // "BB"
fOptions2D->AddEntry("Scatter", kOptions2D+12); // "SCAT"
fOptions2D->AddEntry("Profile", kOptions2D+13); // "SCAT"
fOptions2D->Associate(this);
fOptionsMenu = new TGPopupMenu(gClient->GetRoot());
fOptionsMenu->AddPopup("&General Options...", fOptionsGen);
fOptionsMenu->AddPopup("&1D Options", fOptions1D);
fOptionsMenu->AddPopup("&2D Options", fOptions2D);
fOptionsMenu->AddSeparator();
fOptionsMenu->AddEntry("&Reset options", kOptionsReset);
//--- Help menu
fHelpMenu = new TGPopupMenu(gClient->GetRoot());
fHelpMenu->AddEntry("&About ROOT...", kHelpAbout);
fHelpMenu->AddEntry("&About TreeViewer...", kHelpAboutTV);
fHelpMenu->AddSeparator();
fHelpMenu->AddEntry("&Starting...", kHelpStart);
fHelpMenu->AddEntry("&Layout...", kHelpLayout);
fHelpMenu->AddEntry("&Open/Save", kHelpOpenSave);
fHelpMenu->AddEntry("&Dragging...", kHelpDragging);
fHelpMenu->AddEntry("&Editing expressions...",kHelpEditing);
fHelpMenu->AddEntry("&Session...", kHelpSession);
fHelpMenu->AddEntry("&User commands...", kHelpCommands);
fHelpMenu->AddEntry("&Context menus...", kHelpContext);
fHelpMenu->AddEntry("D&rawing...", kHelpDrawing);
fHelpMenu->AddEntry("&Macros...", kHelpMacros);
fFileMenu->Associate(this);
fEditMenu->Associate(this);
fRunMenu->Associate(this);
fOptionsMenu->Associate(this);
fHelpMenu->Associate(this);
//--- menubar layout hints
fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0,0,1,1);
fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0);
fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight);
//--- create menubar and add popup menus
fMenuBar = new TGMenuBar(this, 1, 1, kHorizontalFrame);
fMenuBar->AddPopup("&File", fFileMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Edit", fEditMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Run", fRunMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Options", fOptionsMenu, fMenuBarItemLayout);
fMenuBar->AddPopup("&Help", fHelpMenu, fMenuBarHelpLayout);
AddFrame(fMenuBar, fMenuBarLayout);
//--- toolbar ----------------------------------------------------------------
fToolBar = new TGToolBar(this, 10, 10, kHorizontalFrame);
fBarLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX);
TGLayoutHints *lo;
lo = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 4,4,0,0);
fWidgets->Add(lo);
//--- label for Command text entry
fBarLbl1 = new TGLabel(fToolBar,"Command");
fToolBar->AddFrame(fBarLbl1,lo);
//--- command text entry
fBarCommand = new TGTextEntry(fToolBar, new TGTextBuffer(250),kBarCommand);
fBarCommand->SetWidth(120);
fBarCommand->Associate(this);
fBarCommand->SetToolTipText("User commands executed via interpreter. Type <ENTER> to execute");
fToolBar->AddFrame(fBarCommand, lo);
//--- first vertical separator
TGVertical3DLine *vSeparator = new TGVertical3DLine(fToolBar);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 4,4,0,0);
fWidgets->Add(lo);
fWidgets->Add(vSeparator);
fToolBar->AddFrame(vSeparator, lo);
lo = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 4,4,0,0);
fWidgets->Add(lo);
//--- label for Option text entry
fBarLbl2 = new TGLabel(fToolBar,"Option");
fToolBar->AddFrame(fBarLbl2, lo);
//--- drawing option text entry
fBarOption = new TGTextEntry(fToolBar, new TGTextBuffer(200),kBarOption);
fBarOption->SetWidth(100);
fBarOption->Associate(this);
fBarOption->SetToolTipText("Histogram graphics option. Type option here and click <Draw> (or <ENTER> to update current histogram).");
fToolBar->AddFrame(fBarOption, lo);
//--- second vertical separator
vSeparator = new TGVertical3DLine(fToolBar);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY, 4,4,0,0);
fWidgets->Add(lo);
fWidgets->Add(vSeparator);
fToolBar->AddFrame(vSeparator, lo);
lo = new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 4,4,0,0);
fWidgets->Add(lo);
//--- label for Histogram text entry
fBarLbl3 = new TGLabel(fToolBar,"Histogram");
fToolBar->AddFrame(fBarLbl3, lo);
//--- histogram name text entry
fBarHist = new TGTextEntry(fToolBar, new TGTextBuffer(100));
fBarHist->SetWidth(50);
fBarHist->SetText("htemp");
fBarHist->SetToolTipText("Name of the histogram created by <Draw> command.");
fToolBar->AddFrame(fBarHist, lo);
//--- Hist check button
fBarH = new TGCheckButton(fToolBar, "Hist");
fBarH->SetToolTipText("Checked : redraw only current histogram");
fBarH->SetState(kButtonUp);
fToolBar->AddFrame(fBarH, lo);
//--- Scan check button
fBarScan = new TGCheckButton(fToolBar, "Scan");
fBarScan->SetState(kButtonUp);
fBarScan->SetToolTipText("Check to redirect TTree::Scan command in a file");
fToolBar->AddFrame(fBarScan, lo);
//--- Rec check button
fBarRec = new TGCheckButton(fToolBar, "Rec");
fBarRec->SetState(kButtonDown);
fBarRec->SetToolTipText("Check to record commands in history file and be verbose");
fToolBar->AddFrame(fBarRec, lo);
//--- 1'st horizontal tool bar separator ----------------------------------------
TGHorizontal3DLine *toolBarSep = new TGHorizontal3DLine(this);
fWidgets->Add(toolBarSep);
AddFrame(toolBarSep, fBarLayout);
AddFrame(fToolBar, fBarLayout);
//--- 2'nd horizontal tool bar separator ----------------------------------------
toolBarSep = new TGHorizontal3DLine(this);
fWidgets->Add(toolBarSep);
AddFrame(toolBarSep, fBarLayout);
//--- Horizontal mother frame ---------------------------------------------------
fHf = new TGHorizontalFrame(this, 10, 10);
//--- Vertical frames
fSlider = new TGDoubleVSlider(fHf, 10, kDoubleScaleBoth, kSLIDER);
// fSlider->SetBackgroundColor(color);
fSlider->Associate(this);
//--- fV1 -----------------------------------------------------------------------
fV1 = new TGVerticalFrame(fHf, 10, 10, kFixedWidth);
fTreeHdr = new TGCompositeFrame(fV1, 10, 10, kSunkenFrame | kVerticalFrame);
fLbl1 = new TGLabel(fTreeHdr, "Current Folder");
lo = new TGLayoutHints(kLHintsLeft | kLHintsTop | kLHintsCenterY, 3, 0, 0, 0);
fWidgets->Add(lo);
fTreeHdr->AddFrame(fLbl1, lo);
lo = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 2, 0, 1, 0);
fWidgets->Add(lo);
fV1->AddFrame(fTreeHdr, lo);
//--- tree view canvas on the left
fTreeView = new TGCanvas(fV1, fV1->GetWidth(), 10, kSunkenFrame | kDoubleBorder);
//--- container frame
fLt = new TGListTree(fTreeView->GetViewPort(), 10, 10, kHorizontalFrame,
GetWhitePixel());
fLt->Associate(this);
fTreeView->SetContainer(fLt);
lo = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 2,0,0,0);
fWidgets->Add(lo);
fV1->AddFrame(fTreeView, lo);
//--- button horizontal frame
fHpb = new TGHorizontalFrame(fV1, fTreeHdr->GetWidth(), 10, kSunkenFrame);
//--- DRAW button
fPicDraw = gClient->GetPicture("draw_t.xpm");
fDRAW = new TGPictureButton(fHpb,fPicDraw,kDRAW);
fDRAW->SetToolTipText("Draw current selection");
fDRAW->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fDRAW, lo);
//--- SPIDER button
fSPIDER = new TGTextButton(fHpb,"SPIDER");
fSPIDER->SetToolTipText("Scan current selection using a spider plot");
fSPIDER->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fSPIDER,lo);
//---connect SPIDER button to ExecuteScan() method
fSPIDER->Connect("Clicked()","TTreeViewer",this,"ExecuteSpider()");
//--- STOP button (breaks current operation)
// fPicStop = gClient->GetPicture("mb_stop_s.xpm");
fPicStop = gClient->GetPicture("stop_t.xpm");
fSTOP = new TGPictureButton(fHpb,fPicStop,kSTOP);
fSTOP->SetToolTipText("Abort current operation");
fSTOP->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fSTOP, lo);
//--- REFR button (breaks current operation)
fPicRefr = gClient->GetPicture("refresh2.xpm");
fREFR = new TGPictureButton(fHpb,fPicRefr,kDRAW);
fREFR->SetToolTipText("Update the tree viewer");
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,4,2);
fWidgets->Add(lo);
fHpb->AddFrame(fREFR, lo);
//---connect REFR button to DoRefresh() method
fREFR->Connect("Clicked()", "TTreeViewer", this, "DoRefresh()");
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 2,2,2,2);
fWidgets->Add(lo);
fV1->AddFrame(fHpb, lo);
//--- fV2
fV2 = new TGVerticalFrame(fHf, 10, 10);
fListHdr = new TGCompositeFrame(fV2, 10, 10, kSunkenFrame | kFitHeight);
fLbl2 = new TGLabel(fListHdr, "Current Tree: ");
lo = new TGLayoutHints(kLHintsTop | kLHintsLeft, 3, 0, 0, 0);
fWidgets->Add(lo);
fListHdr->AddFrame(fLbl2, lo);
//--- progress bar
fProgressBar = new TGHProgressBar(fListHdr);
fProgressBar->SetBarColor("red");
fProgressBar->SetFillType(TGProgressBar::kBlockFill);
lo = new TGLayoutHints(kLHintsBottom | kLHintsExpandX, 2,2,4,2);
fWidgets->Add(lo);
fListHdr->AddFrame(fProgressBar, lo);
lo = new TGLayoutHints(kLHintsTop | kLHintsExpandX | kLHintsExpandY, 2,0,1,2);
fWidgets->Add(lo);
fV2->AddFrame(fListHdr, lo);
fV1->Resize(fTreeHdr->GetDefaultWidth()+100, fV1->GetDefaultHeight());
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
fWidgets->Add(lo);
fHf->AddFrame(fSlider, lo);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
fWidgets->Add(lo);
fHf->AddFrame(fV1, lo);
//--- vertical splitter
TGVSplitter *splitter = new TGVSplitter(fHf);
splitter->SetFrame(fV1,kTRUE);
lo = new TGLayoutHints(kLHintsLeft | kLHintsExpandY);
fWidgets->Add(splitter);
fWidgets->Add(lo);
fHf->AddFrame(splitter,lo);
//-- listview for the content of the tree/branch -----------------------------
fListView = new TGListView(fListHdr,400,300);
//--- container frame
fLVContainer = new TTVLVContainer(fListView->GetViewPort(),400,300);
fLVContainer->Associate(this);
fLVContainer->SetListView(fListView);
fLVContainer->SetViewer(this);
fLVContainer->SetBackgroundColor(GetWhitePixel());
fListView->GetViewPort()->SetBackgroundColor(GetWhitePixel());
fListView->SetContainer(fLVContainer);
fListView->SetViewMode(kLVList);
lo = new TGLayoutHints(kLHintsRight | kLHintsTop | kLHintsExpandX | kLHintsExpandY);
fWidgets->Add(lo);
fListHdr->AddFrame(fListView,lo);
lo = new TGLayoutHints(kLHintsRight | kLHintsExpandX | kLHintsExpandY);
fWidgets->Add(lo);
fHf->AddFrame(fV2,lo);
AddFrame(fHf, lo);
//--- 3rd horizontal tool bar separator ----------------------------------------
toolBarSep = new TGHorizontal3DLine(this);
fWidgets->Add(toolBarSep);
AddFrame(toolBarSep, fBarLayout);
//--- label for IList text entry
fBFrame = new TGHorizontalFrame(this,10,10);
fBLbl4 = new TGLabel(fBFrame,"IList");
lo = new TGLayoutHints(kLHintsLeft | kLHintsBottom, 2,2,2,2);
fWidgets->Add(lo);
fBFrame->AddFrame(fBLbl4, lo);
//--- IList text entry
fBarListIn = new TGTextEntry(fBFrame, new TGTextBuffer(100));
fBarListIn->SetWidth(60);
fBarListIn->SetToolTipText("Name of a previously created event list");
fBFrame->AddFrame(fBarListIn, lo);
//--- label for OList text entry
fBLbl5 = new TGLabel(fBFrame,"OList");
fBFrame->AddFrame(fBLbl5, lo);
//--- OList text entry
fBarListOut = new TGTextEntry(fBFrame, new TGTextBuffer(100));
fBarListOut->SetWidth(60);
fBarListOut->SetToolTipText("Output event list. Use <Draw> to generate it.");
fBFrame->AddFrame(fBarListOut, lo);
//--- Status bar
fStatusBar = new TGStatusBar(fBFrame, 10, 10);
fStatusBar->SetWidth(200);
fStatusBar->Draw3DCorner(kFALSE);
lo = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY | kLHintsLeft | kLHintsExpandX, 2,2,2,2);
fWidgets->Add(lo);
fBFrame->AddFrame(fStatusBar, lo);
//--- RESET button
fReset = new TGTextButton(fBFrame,"RESET",kRESET);
fReset->SetToolTipText("Reset variable's fields and drawing options");
fReset->Associate(this);
lo = new TGLayoutHints(kLHintsTop | kLHintsRight, 2,2,2,2);
fWidgets->Add(lo);
fBFrame->AddFrame(fReset,lo);
//--- group of buttons for session handling
fBGFirst = new TGPictureButton(fBFrame,
gClient->GetPicture("first_t.xpm"), kBGFirst);
fBGFirst->SetToolTipText("First record");
fBGFirst->Associate(this);
fBGPrevious = new TGPictureButton(fBFrame,
gClient->GetPicture("previous_t.xpm"), kBGPrevious);
fBGPrevious->SetToolTipText("Previous record");
fBGPrevious->Associate(this);
fBGRecord = new TGPictureButton(fBFrame,
gClient->GetPicture("record_t.xpm"), kBGRecord);
fBGRecord->SetToolTipText("Record");
fBGRecord->Associate(this);
fBGNext = new TGPictureButton(fBFrame,
gClient->GetPicture("next_t.xpm"), kBGNext);
fBGNext->SetToolTipText("Next record");
fBGNext->Associate(this);
fBGLast = new TGPictureButton(fBFrame,
gClient->GetPicture("last_t.xpm"), kBGLast);
fBGLast->SetToolTipText("Last record");
fBGLast->Associate(this);
fCombo = new TGComboBox(fBFrame, 0);
fCombo->SetHeight(fReset->GetDefaultHeight());
fCombo->SetWidth(100);
fCombo->Associate(this);
lo = new TGLayoutHints(kLHintsCenterY | kLHintsRight, 0,0,2,0);
fWidgets->Add(lo);
fBFrame->AddFrame(fCombo, lo);
fBFrame->AddFrame(fBGLast, lo);
fBFrame->AddFrame(fBGNext, lo);
fBFrame->AddFrame(fBGRecord, lo);
fBFrame->AddFrame(fBGPrevious, lo);
fBFrame->AddFrame(fBGFirst, lo);
lo = new TGLayoutHints(kLHintsExpandX,2,2,2,0);
fWidgets->Add(lo);
AddFrame(fBFrame,lo);
// map the window
SetWindowName("TreeViewer");
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
// put default items in the listview on the right
const TGPicture *pic, *spic;
fLVContainer->RemoveAll();
TTVLVEntry* entry;
Char_t symbol;
entry = new TTVLVEntry(fLVContainer,fPicX,fPicX,new TGString(),0,kLVSmallIcons);
symbol = 'X';
entry->SetUserData(new ULong_t((symbol << 8) | kLTExpressionType | kLTTreeType));
entry->SetToolTipText("X expression. Drag and drop expressions here");
//--- X item
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
entry = new TTVLVEntry(fLVContainer,fPicY,fPicY,new TGString(),0,kLVSmallIcons);
symbol = 'Y';
entry->SetUserData(new ULong_t((symbol << 8) | kLTExpressionType | kLTTreeType));
entry->SetToolTipText("Y expression. Drag and drop expressions here");
//--- Y item
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
entry = new TTVLVEntry(fLVContainer,fPicZ,fPicZ,new TGString(),0,kLVSmallIcons);
symbol = 'Z';
entry->SetUserData(new ULong_t((symbol << 8) | kLTExpressionType | kLTTreeType));
entry->SetToolTipText("Z expression. Drag and drop expressions here");
//--- Z item
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
pic = gClient->GetPicture("cut_t.xpm");
spic = gClient->GetPicture("cut_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,new TGString(),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTCutType));
entry->SetToolTipText("Active cut. Double-click to enable/disable");
//--- Cut item (scissors icon)
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
pic = gClient->GetPicture("pack_t.xpm");
spic = gClient->GetPicture("pack-empty_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,new TGString("Scan box"),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTPackType));
entry->SetToolTipText("Drag and drop expressions/leaves here. Double-click to scan. Check <Scan> to redirect on file.");
//--- Scan Box
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetTrueName("");
//--- 10 expression items
fNexpressions = 10;
for (Int_t i=0; i<fNexpressions; i++) {
pic = gClient->GetPicture("expression_t.xpm");
spic = gClient->GetPicture("expression_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,new TGString(),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTDragType));
entry->SetToolTipText("User defined expression/cut. Double-click to edit");
fLVContainer->AddThisItem(entry);
entry->Empty();
entry->MapWindow();
}
fListView->Layout();
fListView->Resize();
// EmptyAll();
// map the tree if it was supplied in the constructor
if (!fTree) {
fSlider->SetRange(0,1000000);
fSlider->SetPosition(0,1000000);
} else {
fSlider->SetRange(0,fTree->GetEntries()-1);
fSlider->SetPosition(0,fTree->GetEntries()-1);
}
PrintEntries();
fProgressBar->SetPosition(0);
fProgressBar->ShowPosition();
ActivateButtons(kFALSE, kFALSE, kFALSE, kFALSE);
// map the window
///SetWindowName("TreeViewer");
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
}
//______________________________________________________________________________
TTreeViewer::~TTreeViewer()
{
// TTreeViewer destructor.
if (!gClient) return;
gClient->FreePicture(fPicX);
gClient->FreePicture(fPicY);
gClient->FreePicture(fPicZ);
gClient->FreePicture(fPicDraw);
gClient->FreePicture(fPicStop);
gClient->FreePicture(fPicRefr);
fDialogBox = TGSelectBox::GetInstance();
if (fDialogBox) delete fDialogBox;
delete fContextMenu;
delete fBarLbl1;
delete fBarLbl2;
delete fBarLbl3;
delete fBLbl4;
delete fBLbl5;
delete fBarCommand;
delete fBarOption;
delete fBarHist;
delete fBarListIn;
delete fBarListOut;
delete fBarH;
delete fBarScan;
delete fBarRec;
delete fToolBar;
delete fSlider;
delete fV1;
delete fV2;
delete fLbl1;
delete fLbl2;
delete fHf;
delete fTreeHdr;
delete fListHdr;
delete fLt;
delete fTreeView;
delete fLVContainer;
delete fListView;
delete fProgressBar;
delete fHpb;
delete fDRAW;
delete fSPIDER;
delete fSTOP;
delete fReset;
delete fBGFirst;
delete fBGPrevious;
delete fBGRecord;
delete fBGNext;
delete fBGLast;
delete fCombo;
delete fBFrame;
delete fMenuBar;
delete fFileMenu;
delete fEditMenu;
delete fOptionsGen;
delete fOptions1D;
delete fOptions2D;
delete fOptionsMenu;
delete fHelpMenu;
delete fMenuBarLayout;
delete fMenuBarItemLayout;
delete fMenuBarHelpLayout;
delete fBarLayout;
fWidgets->Delete();
delete fWidgets;
if (fTreeList) {
delete fTreeList;
}
delete fTimer;
delete fSession;
}
//______________________________________________________________________________
void TTreeViewer::ActivateButtons(Bool_t first, Bool_t previous,
Bool_t next, Bool_t last)
{
// Enable/disable session buttons.
if (first) fBGFirst->SetState(kButtonUp);
else fBGFirst->SetState(kButtonDisabled);
if (previous) fBGPrevious->SetState(kButtonUp);
else fBGPrevious->SetState(kButtonDisabled);
if (next) fBGNext->SetState(kButtonUp);
else fBGNext->SetState(kButtonDisabled);
if (last) fBGLast->SetState(kButtonUp);
else fBGLast->SetState(kButtonDisabled);
}
//______________________________________________________________________________
const char* TTreeViewer::Cut()
{
// Apply Cut
return fLVContainer->Cut();
}
//______________________________________________________________________________
const char* TTreeViewer::ScanList()
{
// returns scanlist
return fLVContainer->ScanList();
}
//______________________________________________________________________________
void TTreeViewer::SetSession(TTVSession *session)
{
// Set current session
if (session) {
delete fSession;
fSession = session;
}
}
//______________________________________________________________________________
const char* TTreeViewer::EmptyBrackets(const char* name)
{
// Empty the bracket content of a string.
TString stripped(name);
if (!stripped.Contains("[")) return name;
TString retstr(name);
TObjString *objstr;
Int_t index = 0;
while (stripped.Index("[", index) != kNPOS) {
Int_t start = stripped.Index("[", index);
Int_t end = stripped.Index("]", index);
if (end == kNPOS) {
objstr = new TObjString(retstr.Data());
fWidgets->Add(objstr);
return (objstr->GetString()).Data();
}
index = start+2;
retstr = stripped.Remove(start+1, end-start-1);
stripped = retstr;
}
objstr = new TObjString(retstr.Data());
fWidgets->Add(objstr);
return (objstr->GetString()).Data();
}
//______________________________________________________________________________
void TTreeViewer::EmptyAll()
{
// Clear the content of all items in the list view.
fLVContainer->EmptyAll();
}
//______________________________________________________________________________
void TTreeViewer::Empty()
{
// Empty the content of the selected expression.
void *p = 0;
TTVLVEntry *item = 0;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) == 0) {
Warning("Empty", "No item selected.");
return;
}
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTExpressionType)) {
Warning("Empty", "Not expression type.");
return;
}
if (*itemType & kLTPackType) {
item->SetSmallPic(fClient->GetPicture("pack-empty_t.xpm"));
item->SetTrueName("");
return;
}
item->Empty();
}
//______________________________________________________________________________
TTVLVEntry * TTreeViewer::ExpressionItem(Int_t index)
{
// Get the item from a specific position.
return fLVContainer->ExpressionItem(index);
}
//______________________________________________________________________________
TList* TTreeViewer::ExpressionList()
{
// Get the list of expression items.
return fLVContainer->ExpressionList();
}
//______________________________________________________________________________
Int_t TTreeViewer::Dimension()
{
// Compute dimension of the histogram.
fDimension = 0;
if (strlen(Ex())) fDimension++;
if (strlen(Ey())) fDimension++;
if (strlen(Ez())) fDimension++;
return fDimension;
}
//______________________________________________________________________________
void TTreeViewer::ExecuteDraw()
{
// Called when the DRAW button is executed.
TString varexp;
TString command;
Int_t dimension = 0;
TString alias[3];
TTVLVEntry *item;
Int_t i;
// fill in expressions
if (fVarDraw) {
void *p = 0;
dimension = 1;
if (!(item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p))) return;
alias[0] = item->GetAlias();
if (alias[0].BeginsWith("~")) alias[0].Remove(0, 1);
varexp = item->ConvertAliases();
} else {
if (strlen(Ez())) {
dimension++;
varexp = Ez();
item = ExpressionItem(2);
alias[2] = item->GetAlias();
if (alias[2].BeginsWith("~")) alias[2].Remove(0, 1);
}
if (strlen(Ez()) && (strlen(Ex()) || strlen(Ey()))) varexp += ":";
if (strlen(Ey())) {
dimension++;
varexp += Ey();
item = ExpressionItem(1);
alias[1] = item->GetAlias();
if (alias[1].BeginsWith("~")) alias[1].Remove(0, 1);
}
if (strlen(Ey()) && strlen(Ex())) varexp += ":";
if (strlen(Ex())) {
dimension++;
varexp += Ex();
item = ExpressionItem(0);
alias[0] = item->GetAlias();
if (alias[0].BeginsWith("~")) alias[0].Remove(0, 1);
}
}
if (!dimension && !fScanMode) {
Warning("ExecuteDraw", "Nothing to draw on X,Y,Z.");
return;
}
// find ListIn
fTree->SetEventList(0);
TEventList *elist = 0;
if (strlen(fBarListIn->GetText())) {
elist = (TEventList *) gROOT->FindObject(fBarListIn->GetText());
if (elist) fTree->SetEventList(elist);
}
// find ListOut
if (strlen(fBarListOut->GetText())) varexp = TString::Format(">>%s", fBarListOut->GetText());
// find histogram name
if (strcmp("htemp", fBarHist->GetText())) {
varexp += ">>";
varexp += fBarHist->GetText();
}
// find canvas/pad where to draw
TPad *pad = (TPad*)gROOT->GetSelectedPad();
if (pad) pad->cd();
// find graphics option
const char* gopt = fBarOption->GetText();
// just in case a previous interrupt was posted
gROOT->SetInterrupt(kFALSE);
// check if cut is enabled
const char *cut = "";
if (fEnableCut) cut = Cut();
// get entries to be processed
Long64_t nentries = (Long64_t)(fSlider->GetMaxPosition() -
fSlider->GetMinPosition() + 1);
Long64_t firstentry =(Long64_t) fSlider->GetMinPosition();
//printf("firstentry=%lld, nentries=%lld\n",firstentry,nentries);
// check if Scan is checked and if there is something in the box
if (fScanMode) {
// fBarScan->SetState(kButtonUp);
fScanMode = kFALSE;
if (strlen(ScanList())) varexp = ScanList();
command = TString::Format("tv__tree->Scan(\"%s\",\"%s\",\"%s\", %lld, %lld);",
varexp.Data(), cut, gopt, nentries, firstentry);
if (fBarScan->GetState() == kButtonDown) {
((TTreePlayer *)fTree->GetPlayer())->SetScanRedirect(kTRUE);
} else {
((TTreePlayer *)fTree->GetPlayer())->SetScanRedirect(kFALSE);
}
ExecuteCommand(command.Data(), kTRUE);
return;
}
// check if only histogram has to be updated
if (fBarH->GetState() == kButtonDown) {
// reset 'Hist' mode
fBarH->SetState(kButtonUp);
TH1 *hist = fTree->GetHistogram();
if (hist && gPad) {
//hist = (TH1*)gPad->GetListOfPrimitives()->FindObject(fBarHist->GetText());
if (hist) {
// check if graphic option was modified
TString last(fLastOption);
TString current(gopt);
current.ToUpper();
last.ToUpper();
if (current == last) {
gPad->Update();
return;
}
if (dimension == 3 && strlen(gopt)) {
cout << "Graphics option " << gopt << " not valid for 3D histograms" << endl;
return;
}
cout << " Graphics option for current histogram changed to " << gopt << endl;
hist->Draw(gopt);
fLastOption = fBarOption->GetText();
gPad->Update();
return;
}
}
}
// send draw command
fLastOption = fBarOption->GetText();
if (!strlen(gopt) && dimension!=3)
//{
// gopt = "hist";
// fLastOption = "hist";
//}
if (dimension == 3 && strlen(gopt)) {
cout << "Graphics option " << gopt << " not valid for 3D histograms" << endl;
gopt = "";
fLastOption = "";
}
command = TString::Format("tv__tree->Draw(\"%s\",\"%s\",\"%s\", %lld, %lld);",
varexp.Data(), cut, gopt, nentries, firstentry);
if (fCounting) return;
fCounting = kTRUE;
fTree->SetTimerInterval(200);
fTimer->TurnOn();
ExecuteCommand(command.Data());
HandleTimer(fTimer);
fTimer->TurnOff();
fTree->SetTimerInterval(0);
fCounting = kFALSE;
fProgressBar->SetPosition(0);
fProgressBar->ShowPosition();
TH1 *hist = fTree->GetHistogram();
if (hist) {
// put expressions aliases on axes
Int_t current = 0;
for (i=0; i<3; i++) {
if (alias[i].Length()) {
if (i != current) {
alias[current] = alias[i];
alias[i] = "";
}
current++;
}
}
//hist = (TH1*)gPad->GetListOfPrimitives()->FindObject(fBarHist->GetText());
TAxis *axis[3];
axis[0] = hist->GetXaxis();
axis[1] = hist->GetYaxis();
axis[2] = hist->GetZaxis();
for (Int_t ind=0; ind<3; ind++) axis[ind]->SetTitle(alias[ind].Data());
}
if (gPad) gPad->Update();
}
//______________________________________________________________________________
void TTreeViewer::ExecuteSpider()
{
// Draw a spider plot for the selected entries.
TString varexp;
Int_t dimension = 0;
TString alias[3];
TTVLVEntry *item;
Bool_t previousexp = kFALSE;
// fill in expressions
if (strlen(Ez())) {
previousexp = kTRUE;
dimension++;
varexp = Ez();
item = ExpressionItem(2);
alias[2] = item->GetAlias();
if (alias[2].BeginsWith("~")) alias[2].Remove(0, 1);
}
if (strlen(Ez()) && (strlen(Ex()) || strlen(Ey()))) varexp += ":";
if (strlen(Ey())) {
previousexp = kTRUE;
dimension++;
varexp += Ey();
item = ExpressionItem(1);
alias[1] = item->GetAlias();
if (alias[1].BeginsWith("~")) alias[1].Remove(0, 1);
}
if (strlen(Ey()) && strlen(Ex())) varexp += ":";
if (strlen(Ex())) {
previousexp = kTRUE;
dimension++;
varexp += Ex();
item = ExpressionItem(0);
alias[0] = item->GetAlias();
if (alias[0].BeginsWith("~")) alias[0].Remove(0, 1);
}
for(Int_t i=0;i<10;++i){
if(strlen(En(i+5))){
++dimension;
if(previousexp){
varexp += ":";
varexp += En(i+5);
} else varexp = En(i+5);
previousexp = kTRUE;
}
}
if (dimension<3) {
Warning("ExecuteSpider", "Need at least 3 variables");
return;
}
// find ListIn
fTree->SetEventList(0);
TEventList *elist = 0;
if (strlen(fBarListIn->GetText())) {
elist = (TEventList *) gROOT->FindObject(fBarListIn->GetText());
if (elist) fTree->SetEventList(elist);
}
// find ListOut
if (strlen(fBarListOut->GetText())) varexp = TString::Format(">>%s", fBarListOut->GetText());
// find canvas/pad where to draw
TPad *pad = (TPad*)gROOT->GetSelectedPad();
if (pad) pad->cd();
// find graphics option
const char* gopt = fBarOption->GetText();
// just in case a previous interrupt was posted
gROOT->SetInterrupt(kFALSE);
// check if cut is enabled
const char *cut = "";
if (fEnableCut) cut = Cut();
// get entries to be processed
Long64_t nentries = (Long64_t)(fSlider->GetMaxPosition() -
fSlider->GetMinPosition() + 1);
Long64_t firstentry =(Long64_t) fSlider->GetMinPosition();
// create the spider plot
TSpider* spider = new TSpider(fTree,varexp.Data(),cut,Form("%s spider average",gopt),nentries,firstentry);
spider->Draw();
if (gPad) gPad->Update();
}
//______________________________________________________________________________
const char* TTreeViewer::Ex()
{
// Get the expression to be drawn on X axis.
return fLVContainer->Ex();
}
//______________________________________________________________________________
const char* TTreeViewer::Ey()
{
// Get the expression to be drawn on Y axis.
return fLVContainer->Ey();
}
//______________________________________________________________________________
const char* TTreeViewer::Ez()
{
// Get the expression to be drawn on Z axis.
return fLVContainer->Ez();
}
//______________________________________________________________________________
const char* TTreeViewer::En(Int_t n)
{
// Get the n'th expression
TTVLVEntry *e = fLVContainer->ExpressionItem(n);
if(e) return e->ConvertAliases();
return "";
}
//______________________________________________________________________________
void TTreeViewer::EditExpression()
{
// Start the expression editor.
void *p = 0;
// get the selected item
TTVLVEntry *item = 0;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) == 0) {
Warning("EditExpression", "No item selected.");
return;
}
// check if it is an expression
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTExpressionType)) {
Warning("EditExpression", "Not expression type.");
return;
}
// check if the editor is already active
fDialogBox = TGSelectBox::GetInstance();
if (!fDialogBox) {
fDialogBox = new TGSelectBox(fClient->GetRoot(), this, fV1->GetWidth() - 10);
}
// copy current item data into editor boxes
fDialogBox->SetEntry(item);
fDialogBox->SetWindowName("Expression editor");
// check if you are editing the cut expression
if (*itemType & kLTCutType || item->IsCut()) {
fDialogBox->SetLabel("Selection");
} else {
fDialogBox->SetLabel("Expression");
}
}
//______________________________________________________________________________
Int_t TTreeViewer::MakeSelector(const char* selector)
{
// Get use of TTree::MakeSelector() via the context menu.
if (!fTree) return 0;
return fTree->MakeSelector(selector);
}
//______________________________________________________________________________
Long64_t TTreeViewer::Process(const char* filename, Option_t *option, Long64_t nentries, Long64_t firstentry)
{
// Get use of TTree::Process() via the context menu.
if (!fTree) return 0;
return fTree->Process(filename, option, nentries, firstentry);
}
//______________________________________________________________________________
const char *TTreeViewer::GetGrOpt()
{
// Get graph option
return fBarOption->GetText();
}
//______________________________________________________________________________
void TTreeViewer::SetGrOpt(const char *option)
{
// Set graph option
fBarOption->SetText(option);
}
//______________________________________________________________________________
Bool_t TTreeViewer::IsScanRedirected()
{
// Return kTRUE if scan is redirected
return (fBarScan->GetState()==kButtonDown);
}
//______________________________________________________________________________
void TTreeViewer::RemoveItem()
{
// Remove the selected item from the list.
void *p = 0;
TTVLVEntry *item = 0;
// get the selected item
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) == 0) {
Warning("RemoveItem", "No item selected.");
return;
}
// check if it is removable
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTDragType)) {
Warning("RemoveItem", "Not removable type.");
return;
}
fLVContainer->RemoveItem(item);
fListView->Layout();
}
//______________________________________________________________________________
void TTreeViewer::RemoveLastRecord()
{
// Remove the current record.
fSession->RemoveLastRecord();
}
//______________________________________________________________________________
Bool_t TTreeViewer::HandleTimer(TTimer *timer)
{
// This function is called by the fTimer object.
if (fCounting) {
Float_t first = fSlider->GetMinPosition();
Float_t last = fSlider->GetMaxPosition();
Float_t current = (Float_t)fTree->GetReadEntry();
Float_t percent = (current-first+1)/(last-first+1);
fProgressBar->SetPosition(100.*percent);
fProgressBar->ShowPosition();
}
timer->Reset();
return kFALSE;
}
//______________________________________________________________________________
Bool_t TTreeViewer::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2)
{
// Handle menu and other commands generated.
TRootHelpDialog *hd;
switch (GET_MSG(msg)) {
case kC_VSLIDER :
// handle slider messages
PrintEntries();
break;
case kC_TEXTENTRY:
switch (GET_SUBMSG(msg)) {
// handle enter posted by the Command text entry
case kTE_ENTER:
if ((Int_t)parm1 == kBarCommand) {
ExecuteCommand(fBarCommand->GetText());
fBarCommand->Clear();
}
if ((Int_t)parm1 == kBarOption) {
fVarDraw = kFALSE;
fBarH->SetState(kButtonDown);
ExecuteDraw();
fBarH->SetState(kButtonUp);
}
break;
default:
break;
}
break;
case kC_LISTTREE:
switch (GET_SUBMSG(msg)) {
// handle mouse messages in the list-tree (left panel)
case kCT_ITEMCLICK :
if ((parm1==kButton1) || (parm1==kButton3)) {
TGListTreeItem *ltItem = 0;
// get item that sent this
if ((ltItem = fLt->GetSelected()) != 0) {
// get item type
ULong_t *itemType = (ULong_t *)ltItem->GetUserData();
if (*itemType & kLTTreeType) {
// already mapped tree item clicked
Int_t index = (Int_t)(*itemType >> 8);
SwitchTree(index);
if (fTree != fMappedTree) {
// switch also the global "tree" variable
fLVContainer->RemoveNonStatic();
// map it on the right panel
MapTree(fTree);
fListView->Layout();
}
// activate context menu for this tree
if (parm1 == kButton3) {
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
fContextMenu->Popup(x, y, fTree);
}
}
if (*itemType & kLTBranchType) {
// branch item clicked
SetParentTree(ltItem);
if (!fTree) break; // really needed ?
TBranch *branch = fTree->GetBranch(ltItem->GetText());
if (!branch) break;
// check if it is mapped on the right panel
if (branch != fMappedBranch) {
fLVContainer->RemoveNonStatic();
MapBranch(branch);
fStopMapping = kFALSE;
fListView->Layout();
}
// activate context menu for this branch (no *MENU* methods ):)
if (parm1 == kButton3) {
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
fContextMenu->Popup(x, y, branch);
}
}
if (*itemType & kLTLeafType) {
// leaf item clicked
SetParentTree(ltItem);
if (!fTree) break;
// find parent branch
TBranch *branch = fTree->GetBranch(ltItem->GetParent()->GetText());
if (!branch) {
if (fTree != fMappedTree) {
fLVContainer->RemoveNonStatic();
MapTree(fTree);
fListView->Layout();
}
} else {
// check if it is already mapped
if (branch!=fMappedBranch) {
fLVContainer->RemoveNonStatic();
MapBranch(branch);
fStopMapping = kFALSE;
fListView->Layout();
}
}
// select corresponding leaf on the right panel
fLVContainer->SelectItem(ltItem->GetText());
if (parm1 == kButton3) {
// activate context menu for this leaf
ProcessMessage(MK_MSG(kC_CONTAINER, kCT_ITEMCLICK), kButton3, parm2);
}
}
}
}
break;
case kCT_ITEMDBLCLICK :
fClient->NeedRedraw(fLt);
if (parm1 == kButton1) {
// execute double-click action for corresponding item in the right panel
ProcessMessage(MK_MSG(kC_CONTAINER, kCT_ITEMDBLCLICK), kButton1, parm2);
}
break;
default:
break;
}
break;
case kC_COMMAND:
switch (GET_SUBMSG(msg)){
case kCM_COMBOBOX:
fSession->Show(fSession->GetRecord((Int_t)parm2));
break;
case kCM_BUTTON:
switch (parm1) {
// handle button messages
case kRESET:
EmptyAll();
break;
case kDRAW:
fVarDraw = kFALSE;
ExecuteDraw();
break;
case kSTOP:
if (fCounting)
gROOT->SetInterrupt(kTRUE);
break;
case kCLOSE:
SendCloseMessage();
break;
case kBGFirst:
fSession->Show(fSession->First());
break;
case kBGPrevious:
fSession->Show(fSession->Previous());
break;
case kBGRecord:
fSession->AddRecord();
break;
case kBGNext:
fSession->Show(fSession->Next());
break;
case kBGLast:
fSession->Show(fSession->Last());
break;
default:
break;
}
break;
case kCM_MENU:
// handle menu messages
// check if sent by Options menu
if ((parm1>=kOptionsReset) && (parm1<kHelpAbout)) {
Dimension();
if ((fDimension==0) && (parm1>=kOptions1D)) {
Warning("ProcessMessage", "Edit expressions first.");
break;
}
if ((fDimension==1) && (parm1>=kOptions2D)) {
Warning("ProcessMessage", "You have only one expression active.");
break;
}
if ((fDimension==2) && (parm1>=kOptions1D) &&(parm1<kOptions2D)) {
Warning("ProcessMessage", "1D drawing options not apply to 2D histograms.");
break;
}
// make composed option
MapOptions(parm1);
break;
}
switch (parm1) {
case kFileCanvas:
gROOT->MakeDefCanvas();
break;
case kFileBrowse:
if (1) {
static TString dir(".");
TGFileInfo info;
info.fFileTypes = gOpenTypes;
info.fIniDir = StrDup(dir);
new TGFileDialog(fClient->GetRoot(), this, kFDOpen, &info);
if (!info.fFilename) return kTRUE;
dir = info.fIniDir;
TString command = TString::Format("tv__tree_file = new TFile(\"%s\");",
gSystem->UnixPathName(info.fFilename));
ExecuteCommand(command.Data());
ExecuteCommand("tv__tree_file->ls();");
cout << "Use SetTreeName() from context menu and supply a tree name" << endl;
cout << "The context menu is activated by right-clicking the panel from right" << endl;
}
break;
case kFileLoadLibrary:
fBarCommand->SetText("gSystem->Load(\"\");");
if (1) {
Event_t event;
event.fType = kButtonPress;
event.fCode = kButton1;
fBarCommand->HandleButton(&event);
}
fBarCommand->SetCursorPosition(15);
break;
case kFileOpenSession:
if (1) {
static TString dir(".");
TGFileInfo info;
info.fFileTypes = gMacroTypes;
info.fIniDir = StrDup(dir);
new TGFileDialog(fClient->GetRoot(), this, kFDOpen, &info);
if (!info.fFilename) return kTRUE;
dir = info.fIniDir;
gInterpreter->Reset();
if (!gInterpreter->IsLoaded(info.fFilename)) gInterpreter->LoadMacro(info.fFilename);
char command[1024];
command[0] = 0;
sprintf(command,"open_session((void*)0x%lx);", (Long_t)this);
ExecuteCommand(command);
}
break;
case kFileSaveMacro:
SaveSource();
break;
case kFilePrint:
break;
case kFileClose:
SendCloseMessage();
break;
case kFileQuit:
gApplication->Terminate(0);
break;
case kEditExpression:
EditExpression();
break;
case kEditCut:
EditExpression();
break;
case kEditMacro:
break;
case kEditEvent:
break;
case kRunMacro:
break;
case kHelpAbout:
{
#ifdef R__UNIX
TString rootx;
# ifdef ROOTBINDIR
rootx = ROOTBINDIR;
# else
rootx = gSystem->Getenv("ROOTSYS");
if (!rootx.IsNull()) rootx += "/bin";
# endif
rootx += "/root -a &";
gSystem->Exec(rootx);
#else
#ifdef WIN32
new TWin32SplashThread(kTRUE);
#else
char str[32];
sprintf(str, "About ROOT %s...", gROOT->GetVersion());
hd = new TRootHelpDialog(this, str, 600, 400);
hd->SetText(gHelpAbout);
hd->Popup();
#endif
#endif
}
break;
case kHelpAboutTV:
hd = new TRootHelpDialog(this, "About TreeViewer...", 600, 400);
hd->SetText(gTVHelpAbout);
hd->Resize(hd->GetDefaultSize());
hd->Popup();
break;
case kHelpStart:
hd = new TRootHelpDialog(this, "Quick start...", 600, 400);
hd->SetText(gTVHelpStart);
hd->Popup();
break;
case kHelpLayout:
hd = new TRootHelpDialog(this, "Layout...", 600, 400);
hd->SetText(gTVHelpLayout);
hd->Popup();
break;
case kHelpOpenSave:
hd = new TRootHelpDialog(this, "Open/Save...", 600, 400);
hd->SetText(gTVHelpOpenSave);
hd->Popup();
break;
case kHelpDragging:
hd = new TRootHelpDialog(this, "Dragging items...", 600, 400);
hd->SetText(gTVHelpDraggingItems);
hd->Popup();
break;
case kHelpEditing:
hd = new TRootHelpDialog(this, "Editing expressions...", 600, 400);
hd->SetText(gTVHelpEditExpressions);
hd->Popup();
break;
case kHelpSession:
hd = new TRootHelpDialog(this, "Session...", 600, 400);
hd->SetText(gTVHelpSession);
hd->Popup();
break;
case kHelpCommands:
hd = new TRootHelpDialog(this, "Executing user commands...", 600, 400);
hd->SetText(gTVHelpUserCommands);
hd->Popup();
break;
case kHelpContext:
hd = new TRootHelpDialog(this, "Context menus...", 600, 400);
hd->SetText(gTVHelpContext);
hd->Popup();
break;
case kHelpDrawing:
hd = new TRootHelpDialog(this, "Drawing histograms...", 600, 400);
hd->SetText(gTVHelpDrawing);
hd->Popup();
break;
case kHelpMacros:
hd = new TRootHelpDialog(this, "Using macros...", 600, 400);
hd->SetText(gTVHelpMacros);
hd->Popup();
break;
default:
break;
}
break;
default:
break;
}
break;
case kC_CONTAINER:
switch (GET_SUBMSG(msg)) {
// handle messages sent from the listview (right panel)
case kCT_SELCHANGED:
break;
case kCT_ITEMCLICK:
// handle mouse messages
switch (parm1) {
case kButton1:
if (fLVContainer->NumSelected()) {
// get item that sent this
void *p = 0;
TTVLVEntry *item;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) != 0) {
const char* vname = item->GetTrueName();
TString trueName(vname);
if (trueName.Contains("[]")) {
TIter next(fTree->GetListOfLeaves());
TLeaf *leaf;
while((leaf=(TLeaf*)next())) {
if (!strcmp(vname, EmptyBrackets(leaf->GetName())))
vname = leaf->GetName();
}
}
char* msg2 = new char[2000];
// get item type
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (*itemType & kLTTreeType) {
// X, Y or Z clicked
char symbol = (char)((*itemType) >> 8);
sprintf(msg2, "%c expression : %s", symbol, vname);
} else {
if (*itemType & kLTCutType) {
// scissors clicked
sprintf(msg2, "Cut : %s", vname);
} else {
if (*itemType & kLTPackType) {
sprintf(msg2, "Box : %s", vname);
} else {
if (*itemType & kLTExpressionType) {
// expression clicked
sprintf(msg2, "Expression : %s", vname);
} else {
if (*itemType & kLTBranchType) {
sprintf(msg2, "Branch : %s", vname);
} else {
sprintf(msg2, "Leaf : %s", vname);
}
}
}
}
}
// write who is responsable for this
TString message = msg2;
message = message(0,150);
Message(msg2);
delete[] msg2;
// check if this should be pasted into the expression editor
if ((*itemType & kLTBranchType) || (*itemType & kLTCutType)) break;
fDialogBox = TGSelectBox::GetInstance();
if (!fDialogBox || !strlen(vname)) break;
if (item == fDialogBox->EditedEntry()) break;
// paste it
// char first = (char) vname[0];
TString insert(item->GetAlias());
// if (first != '(') insert += "(";
// insert += item->GetAlias();
// if (first != '(') insert += ")";
fDialogBox->GrabPointer();
fDialogBox->InsertText(insert.Data());
// put the cursor at the right position
}
}
break;
case kButton2:
break;
case kButton3:
// activate general context menu
if (fLVContainer->NumSelected()) {
void *p = 0;
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
TTVLVEntry *item = 0;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) != 0) {
fContextMenu->Popup(x, y, item->GetContext());
}
} else { // empty click
Int_t x = (Int_t)(parm2 &0xffff);
Int_t y = (Int_t)((parm2 >> 16) & 0xffff);
fContextMenu->Popup(x, y, this);
}
break;
default:
break;
}
break;
case kCT_ITEMDBLCLICK:
switch (parm1) {
case kButton1:
if (fLVContainer->NumSelected()) {
// get item that sent this
void *p = 0;
TTVLVEntry *item;
if ((item = (TTVLVEntry *) fLVContainer->GetNextSelected(&p)) != 0) {
// get item type
ULong_t *itemType = (ULong_t *) item->GetUserData();
if (!(*itemType & kLTCutType) && !(*itemType & kLTBranchType)
&& !(*itemType & kLTPackType)) {
if (strlen(item->GetTrueName())) {
fVarDraw = kTRUE;
// draw on double-click
ExecuteDraw();
break;
} else {
// open expression in editor
EditExpression();
}
}
if (*itemType & kLTCutType) {
fEnableCut = !fEnableCut;
if (fEnableCut) {
item->SetSmallPic(gClient->GetPicture("cut_t.xpm"));
} else {
item->SetSmallPic(gClient->GetPicture("cut-disable_t.xpm"));
}
}
if (*itemType & kLTPackType) {
fScanMode = kTRUE;
ExecuteDraw();
}
}
}
break;
case kButton2:
break;
case kButton3:
break;
default:
break;
}
break;
case 4:
// cout << "Dragging Item" << endl;
default:
break;
}
break;
default:
break;
}
return kTRUE;
}
//______________________________________________________________________________
void TTreeViewer::CloseWindow()
{
// Close the viewer.
DeleteWindow();
}
//______________________________________________________________________________
void TTreeViewer::ExecuteCommand(const char* command, Bool_t fast)
{
// Execute all user commands.
// Execute the command, write it to history file and echo it to output
if (fBarRec->GetState() == kButtonDown) {
// show the command on the command line
//printf("%s\n", command);
char comm[2000];
comm[0] = 0;
if (strlen(command) > 1999) {
Warning("ExecuteCommand", "Command too long: aborting.");
return;
}
sprintf(comm, "%s", command);
// print the command to history file
Gl_histadd(comm);
}
// execute it
if (fast) {
gROOT->ProcessLineFast(command);
} else {
gROOT->ProcessLine(command);
}
// make sure that 'draw on double-click' flag is reset
fVarDraw = kFALSE;
}
//______________________________________________________________________________
void TTreeViewer::MapOptions(Long_t parm1)
{
// Scan the selected options from option menu.
Int_t ind;
if (parm1 == kOptionsReset) {
for (ind=kOptionsGeneral; ind<kOptionsGeneral+16; ind++)
fOptionsGen->UnCheckEntry(ind);
for (ind=kOptions1D; ind<kOptions1D+12; ind++)
fOptions1D->UnCheckEntry(ind);
for (ind=kOptions2D; ind<kOptions2D+14; ind++)
fOptions2D->UnCheckEntry(ind);
}
if ((parm1 < kOptions1D) && (parm1 != kOptionsReset)) {
if (fOptionsGen->IsEntryChecked((Int_t)parm1)) {
fOptionsGen->UnCheckEntry((Int_t)parm1);
} else {
fOptionsGen->CheckEntry((Int_t)parm1);
if ((Int_t)parm1 != kOptionsGeneral) fOptionsGen->UnCheckEntry((Int_t)kOptionsGeneral);
}
if (fOptionsGen->IsEntryChecked((Int_t)kOptionsGeneral)) {
// uncheck all in this menu
for (ind=kOptionsGeneral+1; ind<kOptionsGeneral+16; ind++) {
fOptionsGen->UnCheckEntry(ind);
}
}
}
if ((parm1 < kOptions2D) && (parm1 >= kOptions1D)) {
if (fOptions1D->IsEntryChecked((Int_t)parm1)) {
fOptions1D->UnCheckEntry((Int_t)parm1);
} else {
fOptions1D->CheckEntry((Int_t)parm1);
if ((Int_t)parm1 != kOptions1D) fOptions1D->UnCheckEntry((Int_t)kOptions1D);
}
if (fOptions1D->IsEntryChecked((Int_t)kOptions1D)) {
// uncheck all in this menu
for (ind=kOptions1D+1; ind<kOptions1D+12; ind++) {
fOptions1D->UnCheckEntry(ind);
}
}
}
if (parm1 >= kOptions2D) {
if (fOptions2D->IsEntryChecked((Int_t)parm1)) {
fOptions2D->UnCheckEntry((Int_t)parm1);
} else {
fOptions2D->CheckEntry((Int_t)parm1);
if ((Int_t)parm1 != kOptions2D) fOptions2D->UnCheckEntry((Int_t)kOptions2D);
}
if (fOptions2D->IsEntryChecked((Int_t)kOptions2D)) {
// uncheck all in this menu
for (ind=kOptions2D+1; ind<kOptions2D+14; ind++) {
fOptions2D->UnCheckEntry(ind);
}
}
}
// concatenate options
fBarOption->SetText("");
for (ind=kOptionsGeneral; ind<kOptionsGeneral+16; ind++) {
if (fOptionsGen->IsEntryChecked(ind))
fBarOption->AppendText(gOptgen[ind-kOptionsGeneral]);
}
if (Dimension() == 1) {
for (ind=kOptions1D; ind<kOptions1D+12; ind++) {
if (fOptions1D->IsEntryChecked(ind))
fBarOption->AppendText(gOpt1D[ind-kOptions1D]);
}
}
if (Dimension() == 2) {
for (ind=kOptions2D; ind<kOptions2D+14; ind++) {
if (fOptions2D->IsEntryChecked(ind))
fBarOption->AppendText(gOpt2D[ind-kOptions2D]);
}
}
}
//______________________________________________________________________________
void TTreeViewer::MapTree(TTree *tree, TGListTreeItem *parent, Bool_t listIt)
{
// Map current tree and expand its content (including friends) in the lists.
if (!tree) return;
TObjArray *branches = tree->GetListOfBranches();
if (!branches) return; // A Chain with no underlying trees.
TBranch *branch;
// loop on branches
Int_t id;
for (id=0; id<branches->GetEntries(); id++) {
branch = (TBranch *)branches->At(id);
if (branch->TestBit(kDoNotProcess)) continue;
TString name = branch->GetName();
if (name.Contains("fBits") || name.Contains("fUniqueID")) continue;
// now map sub-branches
MapBranch(branch, "", parent, listIt);
fStopMapping = kFALSE;
}
//Map branches of friend Trees (if any)
//Look at tree->GetTree() to insure we see both the friendss of a chain
//and the friends of the chain members
TIter nextf( tree->GetTree()->GetListOfFriends() );
TFriendElement *fr;
while ((fr = (TFriendElement*)nextf())) {
TTree * t = fr->GetTree();
branches = t->GetListOfBranches();
for (id=0; id<branches->GetEntries(); id++) {
branch = (TBranch *)branches->At(id);
if (branch->TestBit(kDoNotProcess)) continue;
TString name = branch->GetName();
if (name.Contains("fBits") || name.Contains("fUniqueID")) continue;
// now map sub-branches
MapBranch(branch, fr->GetName(), parent, listIt);
fStopMapping = kFALSE;
}
}
// tell who was last mapped
if (listIt) {
fMappedTree = tree;
fMappedBranch = 0;
}
}
//______________________________________________________________________________
void TTreeViewer::MapBranch(TBranch *branch, const char *prefix, TGListTreeItem *parent, Bool_t listIt)
{
// Map current branch and expand its content in the list view.
if (!branch) return;
TString name;
if (prefix && strlen(prefix) >0) name = Form("%s.%s",prefix,branch->GetName());
else name = branch->GetName();
Int_t ind;
TGListTreeItem *branchItem = 0;
ULong_t *itemType;
// map this branch
if (name.Contains("fBits") || name.Contains("fUniqueID")) return;
if (parent) {
// make list tree items for each branch according to the type
const TGPicture *pic, *spic;
if ((branch->GetListOfBranches()->GetEntries()) ||
(branch->GetNleaves())) {
if (branch->GetListOfBranches()->GetEntries()) {
itemType = new ULong_t(kLTBranchType);
if (branch->InheritsFrom("TBranchObject")) {
pic = gClient->GetPicture("branch-ob_t.xpm");
spic = gClient->GetPicture("branch-ob_t.xpm");
} else {
if (branch->InheritsFrom("TBranchClones")) {
pic = gClient->GetPicture("branch-cl_t.xpm");
spic = gClient->GetPicture("branch-cl_t.xpm");
} else {
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
}
}
branchItem = fLt->AddItem(parent, EmptyBrackets(name), itemType, pic, spic);
} else {
if (branch->GetNleaves() > 1) {
itemType = new ULong_t(kLTBranchType);
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
branchItem = fLt->AddItem(parent, EmptyBrackets(name), itemType,pic, spic);
TObjArray *leaves = branch->GetListOfLeaves();
TLeaf *leaf = 0;
TString leafName;
for (Int_t lf=0; lf<leaves->GetEntries(); lf++) {
leaf = (TLeaf *)leaves->At(lf);
leafName = name;
leafName.Append(".").Append(EmptyBrackets(leaf->GetName()));
itemType = new ULong_t(kLTLeafType);
pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetPicture("leaf_t.xpm");
fLt->AddItem(branchItem, leafName.Data(), itemType, pic, spic);
}
} else {
itemType = new ULong_t(kLTLeafType);
pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetPicture("leaf_t.xpm");
branchItem = fLt->AddItem(parent, EmptyBrackets(name), itemType, pic, spic);
}
}
}
}
// list branch in list view if necessary
if (listIt) {
TGString *textEntry = 0;
const TGPicture *pic, *spic;
TTVLVEntry *entry;
// make list view items in the right frame
if (!fStopMapping) {
fMappedBranch = branch;
fMappedTree = 0;
fStopMapping = kTRUE;
}
if ((branch->GetListOfBranches()->GetEntries()) ||
(branch->GetNleaves())) {
textEntry = new TGString(EmptyBrackets(name.Data()));
if (branch->GetListOfBranches()->GetEntries()) {
if (branch->InheritsFrom("TBranchObject")) {
pic = gClient->GetPicture("branch-ob_t.xpm");
spic = gClient->GetPicture("branch-ob_t.xpm");
} else {
if (branch->InheritsFrom("TBranchClones")) {
pic = gClient->GetPicture("branch-cl_t.xpm");
spic = gClient->GetPicture("branch-cl_t.xpm");
} else {
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
}
}
entry = new TTVLVEntry(fLVContainer,pic,spic,textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTBranchType));
entry->SetToolTipText("Branch with sub-branches. Can not be dragged");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
} else {
if (branch->GetNleaves() > 1) {
if (textEntry) delete textEntry;
textEntry = new TGString(EmptyBrackets(name.Data()));
pic = gClient->GetPicture("branch_t.xpm");
spic = gClient->GetPicture("branch_t.xpm");
entry = new TTVLVEntry(fLVContainer, pic, spic, textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTBranchType));
entry->SetToolTipText("Branch with more than one leaf. Can not be dragged");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
TObjArray *leaves = branch->GetListOfLeaves();
TLeaf *leaf = 0;
TString leafName;
for (Int_t lf=0; lf<leaves->GetEntries(); lf++) {
leaf = (TLeaf *)leaves->At(lf);
leafName = name;
leafName.Append(".").Append(EmptyBrackets(leaf->GetName()));
textEntry = new TGString(leafName.Data());
pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetPicture("leaf_t.xpm");
entry = new TTVLVEntry(fLVContainer, pic, spic, textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTDragType | kLTLeafType));
entry->SetToolTipText("Double-click to draw. Drag to X, Y, Z or scan box.");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
}
} else {
pic = (gClient->GetMimeTypeList())->GetIcon("TLeaf",kFALSE);
if (!pic) pic = gClient->GetPicture("leaf_t.xpm");
spic = gClient->GetMimeTypeList()->GetIcon("TLeaf",kTRUE);
if (!spic) spic = gClient->GetPicture("leaf_t.xpm");
entry = new TTVLVEntry(fLVContainer,pic,spic,textEntry,0,kLVSmallIcons);
entry->SetUserData(new UInt_t(kLTDragType | kLTLeafType));
entry->SetToolTipText("Double-click to draw. Drag to X, Y, Z or scan box.");
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->SetAlias(textEntry->GetString());
}
}
}
}
TObjArray *branches = branch->GetListOfBranches();
TBranch *branchDaughter = 0;
// loop all sub-branches
for (ind=0; ind<branches->GetEntries(); ind++) {
branchDaughter = (TBranch *)branches->UncheckedAt(ind);
// map also all sub-branches
MapBranch(branchDaughter, "", branchItem, listIt);
}
}
//______________________________________________________________________________
void TTreeViewer::NewExpression()
{
// Create new expression
fLVContainer->RemoveNonStatic();
const TGPicture *pic = gClient->GetPicture("expression_t.xpm");
const TGPicture *spic = gClient->GetPicture("expression_t.xpm");
TTVLVEntry *entry = new TTVLVEntry(fLVContainer,pic,spic,
new TGString(),0,kLVSmallIcons);
entry->SetUserData(new ULong_t(kLTExpressionType | kLTDragType));
fLVContainer->AddThisItem(entry);
entry->MapWindow();
entry->Empty();
if (fMappedTree) MapTree(fTree);
if (fMappedBranch) MapBranch(fMappedBranch);
fListView->Layout();
fNexpressions++;
}
//______________________________________________________________________________
void TTreeViewer::SetParentTree(TGListTreeItem *item)
{
// Find parent tree of a clicked item.
if (!item) return;
ULong_t *itemType = (ULong_t *)item->GetUserData();
TGListTreeItem *parent = 0;
Int_t index;
if (!(*itemType & kLTTreeType)) {
parent = item->GetParent();
SetParentTree(parent);
} else {
index = (Int_t)(*itemType >> 8);
SwitchTree(index);
}
}
//______________________________________________________________________________
void TTreeViewer::Message(const char* msg)
{
// Send a message on the status bar.
fStatusBar->SetText(msg);
}
//______________________________________________________________________________
void TTreeViewer::DoError(int level, const char *location, const char *fmt, va_list va) const
{
// Put error/warning into TMsgBox and also forward to console.
TObject::DoError(level, location, fmt, va);
// in case level will abort we will not come here...
static const int buf_size = 2048;
char buf[buf_size], *bp;
int n = vsnprintf(buf, buf_size, fmt, va);
// old vsnprintf's return -1 if string is truncated new ones return
// total number of characters that would have been written
if (n == -1 || n >= buf_size) {
TObject::Warning("DoError", "Error message string truncated...");
}
if (level >= kSysError && level < kFatal)
bp = Form("%s (%s)", buf, gSystem->GetError());
else
bp = buf;
const char *title = "";
if (level == kInfo)
title = "Info";
if (level == kWarning)
title = "Warning";
if (level == kError)
title = "Error";
if (level == kSysError)
title = "System Error";
new TGMsgBox(fClient->GetRoot(), this, title, bp, kMBIconExclamation);
}
//______________________________________________________________________________
void TTreeViewer::PrintEntries()
{
// Print the number of selected entries on status-bar.
if (!fTree) return;
char * msg = new char[100];
sprintf(msg, "First entry : %lld Last entry : %lld",
(Long64_t)fSlider->GetMinPosition(), (Long64_t)fSlider->GetMaxPosition());
Message(msg);
delete[] msg;
}
//______________________________________________________________________________
void TTreeViewer::SaveSource(const char* filename, Option_t *)
{
// Save current session as a C++ macro file.
if (!fTree) return;
char quote = '"';
ofstream out;
Int_t lenfile = strlen(filename);
char * fname;
if (!lenfile) {
fname = (char*)fSourceFile;
lenfile = strlen(fname);
} else {
fname = (char*)filename;
fSourceFile = filename;
}
// if filename is given, open this file, otherwise create a file
// with a name : treeviewer.C
if (lenfile) {
out.open(fname, ios::out);
} else {
fname = new char[13];
strcpy(fname, "treeviewer.C");
out.open(fname, ios::out);
}
if (!out.good ()) {
printf("SaveSource cannot open file : %s\n", fname);
fSourceFile = "treeviewer.C";
if (!lenfile) delete [] fname;
return;
}
// Write macro header and date/time stamp
TDatime t;
TString sname(fname);
sname = sname.ReplaceAll(".C", "");
out <<"void "<<sname.Data()<<"() {"<<endl;
out <<"//=========Macro generated by ROOT version"<<gROOT->GetVersion()<<endl;
out <<"//=========for tree "<<quote<<fTree->GetName()<<quote<<" ("<<t.AsString()<<")"<<endl;
out <<"//===This macro can be opened from a TreeViewer session after loading"<<endl;
out <<"//===the corresponding tree, or by running root with the macro name argument"<<endl<<endl;
out <<" open_session();"<<endl;
out <<"}"<<endl<<endl;
out <<"open_session(void *p = 0) {"<<endl;
out <<" gSystem->Load("<<quote<<"libTreeViewer"<<quote<<");"<<endl;
out <<" TTreeViewer *treeview = (TTreeViewer *) p;"<<endl;
out <<" if (!treeview) treeview = new TTreeViewer();"<<endl;
out <<" TTree *tv_tree = (TTree*)gROOT->FindObject("<<quote<<fTree->GetName()<<quote<<");"<<endl;
out <<" TFile *tv_file = (TFile*)gROOT->GetListOfFiles()->FindObject("<<quote<<fFilename<<quote<<");"<<endl;
out <<" if (!tv_tree) {"<<endl;
out <<" if (!tv_file) tv_file = new TFile("<<quote<<fFilename<<quote<<");"<<endl;
out <<" if (tv_file) tv_tree = (TTree*)tv_file->Get("<<quote<<fTree->GetName()<<quote<<");"<<endl;
out <<" if(!tv_tree) {"<<endl;
out <<" printf(\"Tree %s not found\", fTree->GetName());"<<endl;
out <<" return;"<<endl;
out <<" }"<<endl;
out <<" }"<<endl<<endl;
out <<" treeview->SetTreeName("<<quote<<fTree->GetName()<<quote<<");"<<endl;
out <<" treeview->SetNexpressions("<<fNexpressions<<");"<<endl;
// get expressions
TTVLVEntry *item;
out <<"// Set expressions on axis and cut"<<endl;
out <<" TTVLVEntry *item;"<<endl;
for (Int_t i=0; i<4; i++) {
switch (i) {
case 0:
out <<"// X expression"<<endl;
break;
case 1:
out <<"// Y expression"<<endl;
break;
case 2:
out <<"// Z expression"<<endl;
break;
case 3:
out <<"// Cut expression"<<endl;
break;
default:
break;
}
item = ExpressionItem(i);
out <<" item = treeview->ExpressionItem("<<i<<");"<<endl;
out <<" item->SetExpression("<<quote<<item->GetTrueName()<<quote
<<", "<<quote<<item->GetAlias()<<quote<<");"<<endl;
}
out <<"// Scan list"<<endl;
item = ExpressionItem(4);
out <<" item = treeview->ExpressionItem(4);"<<endl;
out <<" item->SetExpression("<<quote<<item->GetTrueName()<<quote
<<", "<<quote<<"Scan box"<<quote<<");"<<endl;
out <<"// User defined expressions"<<endl;
TString itemType;
for (Int_t crt=5; crt<fNexpressions+5; crt++) {
item = ExpressionItem(crt);
if (item->IsCut())
itemType = "kTRUE";
else
itemType = "kFALSE";
out <<" item = treeview->ExpressionItem("<<crt<<");"<<endl;
out <<" item->SetExpression("<<quote<<item->GetTrueName()<<quote
<<", "<<quote<<item->GetAlias()<<quote<<", "<<itemType.Data()<<");"<<endl;
}
fSession->SaveSource(out);
out <<"}"<<endl;
out.close();
printf("C++ Macro file: %s has been generated\n", fname);
if (!lenfile) delete [] fname;
}
//______________________________________________________________________________
Bool_t TTreeViewer::SwitchTree(Int_t index)
{
// Makes current the tree at a given index in the list.
TTree *tree = (TTree *) fTreeList->At(index);
if (!tree) {
Warning("SwitchTree", "No tree found.");
return kFALSE;
}
if ((tree == fTree) && (tree == fMappedTree)) return kFALSE; // nothing to switch
std::string command;
if (tree != fTree) {
command = "tv__tree = (TTree *) tv__tree_list->At";
command += Form("(%i)",index);
ExecuteCommand(command.c_str());
}
fTree = tree;
fSlider->SetRange(0,fTree->GetEntries()-1);
fSlider->SetPosition(0,fTree->GetEntries()-1);
command = "Current Tree : ";
command += fTree->GetName();
fLbl2->SetText(new TGString(command.c_str()));
fTreeHdr->Layout();
MapSubwindows();
Resize(GetDefaultSize());
MapWindow();
///Resize(); //ia
PrintEntries();
return kTRUE;
}
//______________________________________________________________________________
void TTreeViewer::SetRecordName(const char *name)
{
// Set record name
fSession->SetRecordName(name);
}
//______________________________________________________________________________
void TTreeViewer::SetCurrentRecord(Long64_t entry)
{
// Set current record
fCombo->Select(entry);
}
//______________________________________________________________________________
void TTreeViewer::SetHistogramTitle(const char *title)
{
// Set title of Histogram
if (!gPad) return;
TH1 *hist = (TH1*)gPad->GetListOfPrimitives()->FindObject(fBarHist->GetText());
if (hist) {
hist->SetTitle(title);
gPad->Update();
}
}
//______________________________________________________________________________
void TTreeViewer::SetUserCode(const char *code, Bool_t autoexec)
{
// user defined command for current record
TTVRecord *rec = fSession->GetCurrent();
if (rec) rec->SetUserCode(code, autoexec);
}
//______________________________________________________________________________
void TTreeViewer::UpdateCombo()
{
// Updates combo box to current session entries.
fCombo->RemoveEntries(0, 1000);
for (Long64_t entry=0; entry<fSession->GetEntries(); entry++) {
fCombo->AddEntry(fSession->GetRecord(entry)->GetName(), entry);
}
}
//______________________________________________________________________________
void TTreeViewer::UpdateRecord(const char *name)
{
// Updates current record to new X, Y, Z items.
fSession->UpdateRecord(name);
}
//______________________________________________________________________________
void TTreeViewer::DoRefresh()
{
// This slot is called when button REFR is clicked
fTree->Refresh();
Float_t min = fSlider->GetMinPosition();
Float_t max = (Float_t)fTree->GetEntries()-1;
fSlider->SetRange(min,max);
fSlider->SetPosition(min,max);
ExecuteDraw();
}
|
/* <x0/mod_accesslog.cpp>
*
* This file is part of the x0 web server project and is released under LGPL-3.
*
* (c) 2009 Chrisitan Parpart <trapni@gentoo.org>
*/
#include <x0/server.hpp>
#include <x0/request.hpp>
#include <x0/response.hpp>
#include <x0/header.hpp>
#include <x0/strutils.hpp>
#include <x0/types.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <cstring>
#include <cerrno>
/**
* \ingroup plugins
* \brief implements an accesslog log facility - in spirit of "combined" mode of apache's accesslog logs.
*/
class accesslog_plugin :
public x0::plugin
{
private:
struct logstream
{
std::string filename_;
int fd_;
explicit logstream(const std::string& filename)
{
filename_ = filename;
fd_ = ::open(filename.c_str(), O_APPEND | O_WRONLY | O_CREAT | O_LARGEFILE, 0644);
}
~logstream()
{
if (fd_)
::close(fd_);
}
void write(const std::string message)
{
if (fd_ < 0)
return;
if (::write(fd_, message.c_str(), message.size()) < 0)
DEBUG("Couldn't write accesslog(%s): %s", filename_.c_str(), strerror(errno));
}
};
struct context
{
logstream *stream;
context() : stream(0) {}
context(const context& v) : stream(v.stream) {}
~context() {}
};
logstream *getlogstream(const std::string& filename)
{
auto i = streams_.find(filename);
if (i != streams_.end())
return i->second.get();
return (streams_[filename] = std::shared_ptr<logstream>(new logstream(filename))).get();
}
logstream *getlogstream(x0::request *in)
{
if (context *ctx = server_.context<context>(this, in->hostid()))
return ctx->stream;
return 0;
}
private:
x0::server::request_post_hook::connection c;
std::map<std::string, std::shared_ptr<logstream>> streams_;
public:
accesslog_plugin(x0::server& srv, const std::string& name) :
x0::plugin(srv, name),
streams_()
{
c = srv.request_done.connect(boost::bind(&accesslog_plugin::request_done, this, _1, _2));
}
~accesslog_plugin()
{
server_.request_done.disconnect(c);
}
virtual void configure()
{
std::string default_filename;
bool has_global = server_.config().load("AccessLog", default_filename);
auto hosts = server_.config()["Hosts"].keys<std::string>();
for (auto i = hosts.begin(), e = hosts.end(); i != e; ++i)
{
std::string hostid(*i);
context *ctx = server_.create_context<context>(this, hostid);
std::string filename;
if (server_.config()["Hosts"][hostid]["AccessLog"].load(filename))
{
ctx->stream = getlogstream(filename);
}
else if (has_global)
{
ctx->stream = getlogstream(default_filename);
}
}
}
private:
void request_done(x0::request *in, x0::response *out)
{
if (auto stream = getlogstream(in))
{
std::stringstream sstr;
sstr << hostname(in);
sstr << " - "; // identity as of identd
sstr << username(in) << ' ';
sstr << server_.now().htlog_str() << " \"";
sstr << request_line(in) << "\" ";
sstr << out->status << ' ';
sstr << out->headers["Content-Length"] << ' ';
sstr << '"' << getheader(in, "Referer") << "\" ";
sstr << '"' << getheader(in, "User-Agent") << '"';
sstr << std::endl;
stream->write(sstr.str());
}
}
inline std::string hostname(x0::request *in)
{
std::string name = in->connection.remote_ip();
return !name.empty() ? name : "-";
}
inline std::string username(x0::request *in)
{
return !in->username.empty() ? in->username.str() : "-";
}
inline std::string request_line(x0::request *in)
{
std::stringstream str;
str << in->method.str() << ' ' << in->uri.str()
<< " HTTP/" << in->http_version_major << '.' << in->http_version_minor;
return str.str();
}
inline std::string getheader(const x0::request *in, const std::string& name)
{
x0::buffer_ref value(in->header(name));
return !value.empty() ? value.str() : "-";
}
};
X0_EXPORT_PLUGIN(accesslog);
accesslog: fix timestamp logging
/* <x0/mod_accesslog.cpp>
*
* This file is part of the x0 web server project and is released under LGPL-3.
*
* (c) 2009 Chrisitan Parpart <trapni@gentoo.org>
*/
#include <x0/server.hpp>
#include <x0/request.hpp>
#include <x0/response.hpp>
#include <x0/header.hpp>
#include <x0/strutils.hpp>
#include <x0/types.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <cstring>
#include <cerrno>
/**
* \ingroup plugins
* \brief implements an accesslog log facility - in spirit of "combined" mode of apache's accesslog logs.
*/
class accesslog_plugin :
public x0::plugin
{
private:
struct logstream
{
std::string filename_;
int fd_;
explicit logstream(const std::string& filename)
{
filename_ = filename;
fd_ = ::open(filename.c_str(), O_APPEND | O_WRONLY | O_CREAT | O_LARGEFILE, 0644);
}
~logstream()
{
if (fd_)
::close(fd_);
}
void write(const std::string message)
{
if (fd_ < 0)
return;
if (::write(fd_, message.c_str(), message.size()) < 0)
DEBUG("Couldn't write accesslog(%s): %s", filename_.c_str(), strerror(errno));
}
};
struct context
{
logstream *stream;
context() : stream(0) {}
context(const context& v) : stream(v.stream) {}
~context() {}
};
logstream *getlogstream(const std::string& filename)
{
auto i = streams_.find(filename);
if (i != streams_.end())
return i->second.get();
return (streams_[filename] = std::shared_ptr<logstream>(new logstream(filename))).get();
}
logstream *getlogstream(x0::request *in)
{
if (context *ctx = server_.context<context>(this, in->hostid()))
return ctx->stream;
return 0;
}
private:
x0::server::request_post_hook::connection c;
std::map<std::string, std::shared_ptr<logstream>> streams_;
public:
accesslog_plugin(x0::server& srv, const std::string& name) :
x0::plugin(srv, name),
streams_()
{
c = srv.request_done.connect(boost::bind(&accesslog_plugin::request_done, this, _1, _2));
}
~accesslog_plugin()
{
server_.request_done.disconnect(c);
}
virtual void configure()
{
std::string default_filename;
bool has_global = server_.config().load("AccessLog", default_filename);
auto hosts = server_.config()["Hosts"].keys<std::string>();
for (auto i = hosts.begin(), e = hosts.end(); i != e; ++i)
{
std::string hostid(*i);
context *ctx = server_.create_context<context>(this, hostid);
std::string filename;
if (server_.config()["Hosts"][hostid]["AccessLog"].load(filename))
{
ctx->stream = getlogstream(filename);
}
else if (has_global)
{
ctx->stream = getlogstream(default_filename);
}
}
}
private:
void request_done(x0::request *in, x0::response *out)
{
if (auto stream = getlogstream(in))
{
std::stringstream sstr;
sstr << hostname(in);
sstr << " - "; // identity as of identd
sstr << username(in) << ' ';
sstr << server_.now().htlog_str().c_str() << " \"";
sstr << request_line(in) << "\" ";
sstr << out->status << ' ';
sstr << out->headers["Content-Length"] << ' ';
sstr << '"' << getheader(in, "Referer") << "\" ";
sstr << '"' << getheader(in, "User-Agent") << '"';
sstr << std::endl;
stream->write(sstr.str());
}
}
inline std::string hostname(x0::request *in)
{
std::string name = in->connection.remote_ip();
return !name.empty() ? name : "-";
}
inline std::string username(x0::request *in)
{
return !in->username.empty() ? in->username.str() : "-";
}
inline std::string request_line(x0::request *in)
{
std::stringstream str;
str << in->method.str() << ' ' << in->uri.str()
<< " HTTP/" << in->http_version_major << '.' << in->http_version_minor;
return str.str();
}
inline std::string getheader(const x0::request *in, const std::string& name)
{
x0::buffer_ref value(in->header(name));
return !value.empty() ? value.str() : "-";
}
};
X0_EXPORT_PLUGIN(accesslog);
|
/*
RawSpeed - RAW file decoder.
Copyright (C) 2019 LibRaw LLC (info@libraw.org)
Copyright (C) 2020 Roman Lebedev
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "decompressors/PanasonicDecompressorV6.h" // for PanasonicDecompre...
#include "common/Point.h" // for iPoint2D
#include "common/RawImage.h" // for RawImage, RawImag...
#include "decoders/RawDecoderException.h" // for ThrowRDE
#include <algorithm> // for copy_n
#include <cstdint> // for uint16_t, uint32_t
#include <cstdlib> // for free, malloc
namespace rawspeed {
namespace {
struct pana_cs6_page_decoder {
unsigned int pixelbuffer[14], lastoffset, maxoffset;
unsigned char current;
const unsigned char* buffer;
pana_cs6_page_decoder(const unsigned char* _buffer, unsigned int bsize)
: lastoffset(0), maxoffset(bsize), current(0), buffer(_buffer) {}
void read_page(); // will throw IO error if not enough space in buffer
unsigned int nextpixel() { return current < 14 ? pixelbuffer[current++] : 0; }
};
void pana_cs6_page_decoder::read_page() {
if (!buffer || (maxoffset - lastoffset < 16))
ThrowRDE("Input failure");
#define wbuffer(i) ((unsigned short)buffer[lastoffset + 15 - i])
pixelbuffer[0] = (wbuffer(0) << 6) | (wbuffer(1) >> 2); // 14 bit
pixelbuffer[1] =
(((wbuffer(1) & 0x3) << 12) | (wbuffer(2) << 4) | (wbuffer(3) >> 4)) &
0x3fff;
pixelbuffer[2] = (wbuffer(3) >> 2) & 0x3;
pixelbuffer[3] = ((wbuffer(3) & 0x3) << 8) | wbuffer(4);
pixelbuffer[4] = (wbuffer(5) << 2) | (wbuffer(6) >> 6);
pixelbuffer[5] = ((wbuffer(6) & 0x3f) << 4) | (wbuffer(7) >> 4);
pixelbuffer[6] = (wbuffer(7) >> 2) & 0x3;
pixelbuffer[7] = ((wbuffer(7) & 0x3) << 8) | wbuffer(8);
pixelbuffer[8] = ((wbuffer(9) << 2) & 0x3fc) | (wbuffer(10) >> 6);
pixelbuffer[9] = ((wbuffer(10) << 4) | (wbuffer(11) >> 4)) & 0x3ff;
pixelbuffer[10] = (wbuffer(11) >> 2) & 0x3;
pixelbuffer[11] = ((wbuffer(11) & 0x3) << 8) | wbuffer(12);
pixelbuffer[12] = (((wbuffer(13) << 2) & 0x3fc) | wbuffer(14) >> 6) & 0x3ff;
pixelbuffer[13] = ((wbuffer(14) << 4) | (wbuffer(15) >> 4)) & 0x3ff;
#undef wbuffer
current = 0;
lastoffset += 16;
}
} // namespace
PanasonicDecompressorV6::PanasonicDecompressorV6(const RawImage& img,
ByteStream input_,
uint32_t bps_)
: mRaw(img), input(std::move(input_)) {
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
mRaw->getBpp() != sizeof(uint16_t))
ThrowRDE("Unexpected component count / data type");
if (!mRaw->dim.hasPositiveArea()) {
ThrowRDE("Unexpected image dimensions found: (%i; %i)", mRaw->dim.x,
mRaw->dim.y);
}
}
void PanasonicDecompressorV6::decompress() {
const int rowstep = 16;
const int blocksperrow = mRaw->dim.x / 11;
const int rowbytes = blocksperrow * 16;
for (int row = 0; row < mRaw->dim.y - rowstep + 1; row += rowstep) {
int rowstoread = std::min(rowstep, mRaw->dim.y - row);
pana_cs6_page_decoder page(input.getData(rowbytes * rowstep),
rowbytes * rowstoread);
for (int crow = 0, col = 0; crow < rowstoread; crow++, col = 0) {
auto* rowptr =
reinterpret_cast<uint16_t*>(mRaw->getDataUncropped(0, row + crow));
for (int rblock = 0; rblock < blocksperrow; rblock++) {
page.read_page();
unsigned oddeven[2] = {0, 0};
unsigned nonzero[2] = {0, 0};
unsigned pmul = 0;
unsigned pixel_base = 0;
for (int pix = 0; pix < 11; pix++) {
if (pix % 3 == 2) {
unsigned base = page.nextpixel();
if (base > 3)
ThrowRDE("Invariant failure");
if (base == 3)
base = 4;
pixel_base = 0x200 << base;
pmul = 1 << base;
}
unsigned epixel = page.nextpixel();
if (oddeven[pix % 2]) {
epixel *= pmul;
if (pixel_base < 0x2000 && nonzero[pix % 2] > pixel_base)
epixel += nonzero[pix % 2] - pixel_base;
nonzero[pix % 2] = epixel;
} else {
oddeven[pix % 2] = epixel;
if (epixel)
nonzero[pix % 2] = epixel;
else
epixel = nonzero[pix % 2];
}
auto spix = static_cast<unsigned>(static_cast<int>(epixel) - 0xf);
if (spix <= 0xffff)
rowptr[col++] = spix & 0xffff;
else {
epixel = static_cast<signed int>(epixel + 0x7ffffff1) >> 0x1f;
rowptr[col++] = epixel & 0x3fff;
}
}
}
}
}
}
} // namespace rawspeed
PanasonicDecompressorV6: clang-tidy: avoid using macro where lambda would work
/*
RawSpeed - RAW file decoder.
Copyright (C) 2019 LibRaw LLC (info@libraw.org)
Copyright (C) 2020 Roman Lebedev
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "decompressors/PanasonicDecompressorV6.h" // for PanasonicDecompre...
#include "common/Point.h" // for iPoint2D
#include "common/RawImage.h" // for RawImage, RawImag...
#include "decoders/RawDecoderException.h" // for ThrowRDE
#include <algorithm> // for copy_n
#include <cstdint> // for uint16_t, uint32_t
#include <cstdlib> // for free, malloc
namespace rawspeed {
namespace {
struct pana_cs6_page_decoder {
unsigned int pixelbuffer[14], lastoffset, maxoffset;
unsigned char current;
const unsigned char* buffer;
pana_cs6_page_decoder(const unsigned char* _buffer, unsigned int bsize)
: lastoffset(0), maxoffset(bsize), current(0), buffer(_buffer) {}
void read_page(); // will throw IO error if not enough space in buffer
unsigned int nextpixel() { return current < 14 ? pixelbuffer[current++] : 0; }
};
void pana_cs6_page_decoder::read_page() {
if (!buffer || (maxoffset - lastoffset < 16))
ThrowRDE("Input failure");
auto wbuffer = [&](int i) {
return (unsigned short)buffer[lastoffset + 15 - i];
};
pixelbuffer[0] = (wbuffer(0) << 6) | (wbuffer(1) >> 2); // 14 bit
pixelbuffer[1] =
(((wbuffer(1) & 0x3) << 12) | (wbuffer(2) << 4) | (wbuffer(3) >> 4)) &
0x3fff;
pixelbuffer[2] = (wbuffer(3) >> 2) & 0x3;
pixelbuffer[3] = ((wbuffer(3) & 0x3) << 8) | wbuffer(4);
pixelbuffer[4] = (wbuffer(5) << 2) | (wbuffer(6) >> 6);
pixelbuffer[5] = ((wbuffer(6) & 0x3f) << 4) | (wbuffer(7) >> 4);
pixelbuffer[6] = (wbuffer(7) >> 2) & 0x3;
pixelbuffer[7] = ((wbuffer(7) & 0x3) << 8) | wbuffer(8);
pixelbuffer[8] = ((wbuffer(9) << 2) & 0x3fc) | (wbuffer(10) >> 6);
pixelbuffer[9] = ((wbuffer(10) << 4) | (wbuffer(11) >> 4)) & 0x3ff;
pixelbuffer[10] = (wbuffer(11) >> 2) & 0x3;
pixelbuffer[11] = ((wbuffer(11) & 0x3) << 8) | wbuffer(12);
pixelbuffer[12] = (((wbuffer(13) << 2) & 0x3fc) | wbuffer(14) >> 6) & 0x3ff;
pixelbuffer[13] = ((wbuffer(14) << 4) | (wbuffer(15) >> 4)) & 0x3ff;
#undef wbuffer
current = 0;
lastoffset += 16;
}
} // namespace
PanasonicDecompressorV6::PanasonicDecompressorV6(const RawImage& img,
ByteStream input_,
uint32_t bps_)
: mRaw(img), input(std::move(input_)) {
if (mRaw->getCpp() != 1 || mRaw->getDataType() != TYPE_USHORT16 ||
mRaw->getBpp() != sizeof(uint16_t))
ThrowRDE("Unexpected component count / data type");
if (!mRaw->dim.hasPositiveArea()) {
ThrowRDE("Unexpected image dimensions found: (%i; %i)", mRaw->dim.x,
mRaw->dim.y);
}
}
void PanasonicDecompressorV6::decompress() {
const int rowstep = 16;
const int blocksperrow = mRaw->dim.x / 11;
const int rowbytes = blocksperrow * 16;
for (int row = 0; row < mRaw->dim.y - rowstep + 1; row += rowstep) {
int rowstoread = std::min(rowstep, mRaw->dim.y - row);
pana_cs6_page_decoder page(input.getData(rowbytes * rowstep),
rowbytes * rowstoread);
for (int crow = 0, col = 0; crow < rowstoread; crow++, col = 0) {
auto* rowptr =
reinterpret_cast<uint16_t*>(mRaw->getDataUncropped(0, row + crow));
for (int rblock = 0; rblock < blocksperrow; rblock++) {
page.read_page();
unsigned oddeven[2] = {0, 0};
unsigned nonzero[2] = {0, 0};
unsigned pmul = 0;
unsigned pixel_base = 0;
for (int pix = 0; pix < 11; pix++) {
if (pix % 3 == 2) {
unsigned base = page.nextpixel();
if (base > 3)
ThrowRDE("Invariant failure");
if (base == 3)
base = 4;
pixel_base = 0x200 << base;
pmul = 1 << base;
}
unsigned epixel = page.nextpixel();
if (oddeven[pix % 2]) {
epixel *= pmul;
if (pixel_base < 0x2000 && nonzero[pix % 2] > pixel_base)
epixel += nonzero[pix % 2] - pixel_base;
nonzero[pix % 2] = epixel;
} else {
oddeven[pix % 2] = epixel;
if (epixel)
nonzero[pix % 2] = epixel;
else
epixel = nonzero[pix % 2];
}
auto spix = static_cast<unsigned>(static_cast<int>(epixel) - 0xf);
if (spix <= 0xffff)
rowptr[col++] = spix & 0xffff;
else {
epixel = static_cast<signed int>(epixel + 0x7ffffff1) >> 0x1f;
rowptr[col++] = epixel & 0x3fff;
}
}
}
}
}
}
} // namespace rawspeed
|
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/*
$Log$
Revision 1.7 2001/10/21 19:04:55 hristov
Several patches were done to adapt the barel reconstruction to the multi-event case. Some memory leaks were corrected. (Yu.Belikov)
Revision 1.6 2001/08/30 09:28:48 hristov
TTree names are explicitly set via SetName(name) and then Write() is called
Revision 1.5 2001/07/20 14:32:44 kowal2
Processing of many events possible now
Revision 1.4 2001/04/17 08:06:27 hristov
Possibility to define the magnetic field in the reconstruction (Yu.Belikov)
Revision 1.3 2000/10/05 16:14:01 kowal2
Forward declarations.
Revision 1.2 2000/06/30 12:07:50 kowal2
Updated from the TPC-PreRelease branch
Revision 1.1.2.1 2000/06/25 08:53:55 kowal2
Splitted from AliTPCtracking
*/
//-------------------------------------------------------
// Implementation of the TPC clusterer
//
// Origin: Jouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------
#include "AliTPCclusterer.h"
#include "AliTPCcluster.h"
#include <TObjArray.h>
#include <TFile.h>
#include "AliTPCClustersArray.h"
#include "AliTPCClustersRow.h"
#include "AliDigits.h"
#include "AliSimDigits.h"
#include "AliTPCParam.h"
#include <iostream.h>
#include <TTree.h>
void AliTPCclusterer::FindPeaks(Int_t k,Int_t max,
AliBin *b,Int_t *idx,UInt_t *msk,Int_t& n) {
//find local maxima
if (n<31)
if (IsMaximum(k,max,b)) {
idx[n]=k; msk[n]=(2<<n);
n++;
}
b[k].SetMask(0);
if (b[k-max].GetMask()&1) FindPeaks(k-max,max,b,idx,msk,n);
if (b[k-1 ].GetMask()&1) FindPeaks(k-1 ,max,b,idx,msk,n);
if (b[k+max].GetMask()&1) FindPeaks(k+max,max,b,idx,msk,n);
if (b[k+1 ].GetMask()&1) FindPeaks(k+1 ,max,b,idx,msk,n);
}
void AliTPCclusterer::MarkPeak(Int_t k, Int_t max, AliBin *bins, UInt_t m) {
//mark this peak
UShort_t q=bins[k].GetQ();
bins[k].SetMask(bins[k].GetMask()|m);
if (bins[k-max].GetQ() <= q)
if ((bins[k-max].GetMask()&m) == 0) MarkPeak(k-max,max,bins,m);
if (bins[k-1 ].GetQ() <= q)
if ((bins[k-1 ].GetMask()&m) == 0) MarkPeak(k-1 ,max,bins,m);
if (bins[k+max].GetQ() <= q)
if ((bins[k+max].GetMask()&m) == 0) MarkPeak(k+max,max,bins,m);
if (bins[k+1 ].GetQ() <= q)
if ((bins[k+1 ].GetMask()&m) == 0) MarkPeak(k+1 ,max,bins,m);
}
void AliTPCclusterer::MakeCluster(Int_t k,Int_t max,AliBin *bins,UInt_t m,
AliTPCcluster &c) {
//make cluster using digits of this peak
Float_t q=(Float_t)bins[k].GetQ();
Int_t i=k/max, j=k-i*max;
c.SetQ(c.GetQ()+q);
c.SetY(c.GetY()+i*q);
c.SetZ(c.GetZ()+j*q);
c.SetSigmaY2(c.GetSigmaY2()+i*i*q);
c.SetSigmaZ2(c.GetSigmaZ2()+j*j*q);
bins[k].SetMask(0xFFFFFFFE);
if (bins[k-max].GetMask() == m) MakeCluster(k-max,max,bins,m,c);
if (bins[k-1 ].GetMask() == m) MakeCluster(k-1 ,max,bins,m,c);
if (bins[k+max].GetMask() == m) MakeCluster(k+max,max,bins,m,c);
if (bins[k+1 ].GetMask() == m) MakeCluster(k+1 ,max,bins,m,c);
}
//_____________________________________________________________________________
void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of, Int_t eventn)
{
//-----------------------------------------------------------------
// This is a simple cluster finder.
//-----------------------------------------------------------------
TDirectory *savedir=gDirectory;
if (!of->IsOpen()) {
cerr<<"AliTPC::Digits2Clusters(): output file not open !\n";
return;
}
const Int_t kMAXZ=par->GetMaxTBin()+2;
char dname[100];
char cname[100];
if (eventn==-1) {
// for backward compatibility
sprintf(dname,"TreeD_75x40_100x60_150x60");
sprintf(cname,"TreeC_TPC");
}
else {
sprintf(dname,"TreeD_75x40_100x60_150x60_%d",eventn);
sprintf(cname,"TreeC_TPC_%d",eventn);
}
TTree *t = (TTree *)gDirectory->Get(dname);
AliSimDigits digarr, *dummy=&digarr;
t->GetBranch("Segment")->SetAddress(&dummy);
Stat_t nentries = t->GetEntries();
of->cd();
((AliTPCParam*)par)->Write(par->GetTitle());
AliTPCClustersArray carray;
carray.Setup(par);
carray.SetClusterType("AliTPCcluster");
carray.MakeTree();
Int_t nclusters=0;
for (Int_t n=0; n<nentries; n++) {
t->GetEvent(n);
Int_t sec, row;
if (!par->AdjustSectorRow(digarr.GetID(),sec,row)) {
cerr<<"AliTPC warning: invalid segment ID ! "<<digarr.GetID()<<endl;
continue;
}
AliTPCClustersRow *clrow=carray.CreateRow(sec,row);
Float_t rx=par->GetPadRowRadii(sec,row);
Int_t npads, sign;
{
const Int_t kNIS=par->GetNInnerSector(), kNOS=par->GetNOuterSector();
if (sec < kNIS) {
npads = par->GetNPadsLow(row);
sign = (sec < kNIS/2) ? 1 : -1;
} else {
npads = par->GetNPadsUp(row);
sign = ((sec-kNIS) < kNOS/2) ? 1 : -1;
}
}
const Int_t kMAXBIN=kMAXZ*(npads+2);
AliBin *bins=new AliBin[kMAXBIN];
for (Int_t ii=0;ii<kMAXBIN;ii++) {
bins[ii].SetQ(0); bins[ii].SetMask(0xFFFFFFFE);
}
digarr.First();
do {
Short_t dig=digarr.CurrentDigit();
if (dig<=par->GetZeroSup()) continue;
Int_t j=digarr.CurrentRow()+1, i=digarr.CurrentColumn()+1;
bins[i*kMAXZ+j].SetQ(dig);
bins[i*kMAXZ+j].SetMask(1);
} while (digarr.Next());
Int_t ncl=0;
for (Int_t i=0; i<kMAXBIN; i++) {
if ((bins[i].GetMask()&1) == 0) continue;
Int_t idx[32]; UInt_t msk[32]; Int_t npeaks=0;
FindPeaks(i, kMAXZ, bins, idx, msk, npeaks);
if (npeaks>30) continue;
Int_t k,l;
for (k=0; k<npeaks-1; k++){//mark adjacent peaks
if (idx[k] < 0) continue; //this peak is already removed
for (l=k+1; l<npeaks; l++) {
if (idx[l] < 0) continue; //this peak is already removed
Int_t ki=idx[k]/kMAXZ, kj=idx[k] - ki*kMAXZ;
Int_t li=idx[l]/kMAXZ, lj=idx[l] - li*kMAXZ;
Int_t di=TMath::Abs(ki - li);
Int_t dj=TMath::Abs(kj - lj);
if (di>1 || dj>1) continue;
if (bins[idx[k]].GetQ() > bins[idx[l]].GetQ()) {
msk[l]=msk[k];
idx[l]*=-1;
} else {
msk[k]=msk[l];
idx[k]*=-1;
break;
}
}
}
for (k=0; k<npeaks; k++) {
MarkPeak(TMath::Abs(idx[k]), kMAXZ, bins, msk[k]);
}
for (k=0; k<npeaks; k++) {
if (idx[k] < 0) continue; //removed peak
AliTPCcluster c;
MakeCluster(idx[k], kMAXZ, bins, msk[k], c);
if (c.GetQ() < 5) continue; //noise cluster
c.SetY(c.GetY()/c.GetQ());
c.SetZ(c.GetZ()/c.GetQ());
Float_t s2 = c.GetSigmaY2()/c.GetQ() - c.GetY()*c.GetY();
Float_t w=par->GetPadPitchWidth(sec);
c.SetSigmaY2((s2 + 1./12.)*w*w);
if (s2 != 0.) {
c.SetSigmaY2(c.GetSigmaY2()*0.108);
if (sec<par->GetNInnerSector()) c.SetSigmaY2(c.GetSigmaY2()*2.07);
}
s2 = c.GetSigmaZ2()/c.GetQ() - c.GetZ()*c.GetZ();
w=par->GetZWidth();
c.SetSigmaZ2((s2 + 1./12.)*w*w);
if (s2 != 0.) {
c.SetSigmaZ2(c.GetSigmaZ2()*0.169);
if (sec<par->GetNInnerSector()) c.SetSigmaZ2(c.GetSigmaZ2()*1.77);
}
c.SetY((c.GetY() - 0.5 - 0.5*npads)*par->GetPadPitchWidth(sec));
c.SetZ(par->GetZWidth()*(c.GetZ()-1));
c.SetZ(c.GetZ() - 3.*par->GetZSigma()); // PASA delay
c.SetZ(sign*(par->GetZLength() - c.GetZ()));
if (rx<230./250.*TMath::Abs(c.GetZ())) continue;
Int_t ki=idx[k]/kMAXZ, kj=idx[k] - ki*kMAXZ;
c.SetLabel(digarr.GetTrackID(kj-1,ki-1,0),0);
c.SetLabel(digarr.GetTrackID(kj-1,ki-1,1),1);
c.SetLabel(digarr.GetTrackID(kj-1,ki-1,2),2);
c.SetQ(bins[idx[k]].GetQ());
if (ki==1 || ki==npads || kj==1 || kj==kMAXZ-2) {
c.SetSigmaY2(c.GetSigmaY2()*25.);
c.SetSigmaZ2(c.GetSigmaZ2()*4.);
}
clrow->InsertCluster(&c); ncl++;
}
}
carray.StoreRow(sec,row);
carray.ClearRow(sec,row);
//cerr<<"sector, row, compressed digits, clusters: "
//<<sec<<' '<<row<<' '<<digarr.GetSize()<<' '<<ncl<<" \r";
nclusters+=ncl;
delete[] bins;
}
cerr<<"Number of found clusters : "<<nclusters<<" \n";
carray.GetTree()->SetName(cname);
carray.GetTree()->Write();
savedir->cd();
delete t; //Thanks to Mariana Bondila
}
Protection against nonexisting input tree
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/*
$Log$
Revision 1.8 2002/03/29 06:57:45 kowal2
Restored backward compatibility to use the hits from Dec. 2000 production.
Revision 1.7 2001/10/21 19:04:55 hristov
Several patches were done to adapt the barel reconstruction to the multi-event case. Some memory leaks were corrected. (Yu.Belikov)
Revision 1.6 2001/08/30 09:28:48 hristov
TTree names are explicitly set via SetName(name) and then Write() is called
Revision 1.5 2001/07/20 14:32:44 kowal2
Processing of many events possible now
Revision 1.4 2001/04/17 08:06:27 hristov
Possibility to define the magnetic field in the reconstruction (Yu.Belikov)
Revision 1.3 2000/10/05 16:14:01 kowal2
Forward declarations.
Revision 1.2 2000/06/30 12:07:50 kowal2
Updated from the TPC-PreRelease branch
Revision 1.1.2.1 2000/06/25 08:53:55 kowal2
Splitted from AliTPCtracking
*/
//-------------------------------------------------------
// Implementation of the TPC clusterer
//
// Origin: Jouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------
#include "AliTPCclusterer.h"
#include "AliTPCcluster.h"
#include <TObjArray.h>
#include <TFile.h>
#include "AliTPCClustersArray.h"
#include "AliTPCClustersRow.h"
#include "AliDigits.h"
#include "AliSimDigits.h"
#include "AliTPCParam.h"
#include <iostream.h>
#include <TTree.h>
void AliTPCclusterer::FindPeaks(Int_t k,Int_t max,
AliBin *b,Int_t *idx,UInt_t *msk,Int_t& n) {
//find local maxima
if (n<31)
if (IsMaximum(k,max,b)) {
idx[n]=k; msk[n]=(2<<n);
n++;
}
b[k].SetMask(0);
if (b[k-max].GetMask()&1) FindPeaks(k-max,max,b,idx,msk,n);
if (b[k-1 ].GetMask()&1) FindPeaks(k-1 ,max,b,idx,msk,n);
if (b[k+max].GetMask()&1) FindPeaks(k+max,max,b,idx,msk,n);
if (b[k+1 ].GetMask()&1) FindPeaks(k+1 ,max,b,idx,msk,n);
}
void AliTPCclusterer::MarkPeak(Int_t k, Int_t max, AliBin *bins, UInt_t m) {
//mark this peak
UShort_t q=bins[k].GetQ();
bins[k].SetMask(bins[k].GetMask()|m);
if (bins[k-max].GetQ() <= q)
if ((bins[k-max].GetMask()&m) == 0) MarkPeak(k-max,max,bins,m);
if (bins[k-1 ].GetQ() <= q)
if ((bins[k-1 ].GetMask()&m) == 0) MarkPeak(k-1 ,max,bins,m);
if (bins[k+max].GetQ() <= q)
if ((bins[k+max].GetMask()&m) == 0) MarkPeak(k+max,max,bins,m);
if (bins[k+1 ].GetQ() <= q)
if ((bins[k+1 ].GetMask()&m) == 0) MarkPeak(k+1 ,max,bins,m);
}
void AliTPCclusterer::MakeCluster(Int_t k,Int_t max,AliBin *bins,UInt_t m,
AliTPCcluster &c) {
//make cluster using digits of this peak
Float_t q=(Float_t)bins[k].GetQ();
Int_t i=k/max, j=k-i*max;
c.SetQ(c.GetQ()+q);
c.SetY(c.GetY()+i*q);
c.SetZ(c.GetZ()+j*q);
c.SetSigmaY2(c.GetSigmaY2()+i*i*q);
c.SetSigmaZ2(c.GetSigmaZ2()+j*j*q);
bins[k].SetMask(0xFFFFFFFE);
if (bins[k-max].GetMask() == m) MakeCluster(k-max,max,bins,m,c);
if (bins[k-1 ].GetMask() == m) MakeCluster(k-1 ,max,bins,m,c);
if (bins[k+max].GetMask() == m) MakeCluster(k+max,max,bins,m,c);
if (bins[k+1 ].GetMask() == m) MakeCluster(k+1 ,max,bins,m,c);
}
//_____________________________________________________________________________
void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of, Int_t eventn)
{
//-----------------------------------------------------------------
// This is a simple cluster finder.
//-----------------------------------------------------------------
TDirectory *savedir=gDirectory;
if (!of->IsOpen()) {
cerr<<"AliTPC::Digits2Clusters(): output file not open !\n";
return;
}
const Int_t kMAXZ=par->GetMaxTBin()+2;
char dname[100];
char cname[100];
if (eventn==-1) {
// for backward compatibility
sprintf(dname,"TreeD_75x40_100x60_150x60");
sprintf(cname,"TreeC_TPC");
}
else {
sprintf(dname,"TreeD_75x40_100x60_150x60_%d",eventn);
sprintf(cname,"TreeC_TPC_%d",eventn);
}
TTree *t = (TTree *)gDirectory->Get(dname);
if (!t) {
cerr<<"Input tree with "<<dname<<" not found"<<endl;
return;
}
AliSimDigits digarr, *dummy=&digarr;
t->GetBranch("Segment")->SetAddress(&dummy);
Stat_t nentries = t->GetEntries();
of->cd();
((AliTPCParam*)par)->Write(par->GetTitle());
AliTPCClustersArray carray;
carray.Setup(par);
carray.SetClusterType("AliTPCcluster");
carray.MakeTree();
Int_t nclusters=0;
for (Int_t n=0; n<nentries; n++) {
t->GetEvent(n);
Int_t sec, row;
if (!par->AdjustSectorRow(digarr.GetID(),sec,row)) {
cerr<<"AliTPC warning: invalid segment ID ! "<<digarr.GetID()<<endl;
continue;
}
AliTPCClustersRow *clrow=carray.CreateRow(sec,row);
Float_t rx=par->GetPadRowRadii(sec,row);
Int_t npads, sign;
{
const Int_t kNIS=par->GetNInnerSector(), kNOS=par->GetNOuterSector();
if (sec < kNIS) {
npads = par->GetNPadsLow(row);
sign = (sec < kNIS/2) ? 1 : -1;
} else {
npads = par->GetNPadsUp(row);
sign = ((sec-kNIS) < kNOS/2) ? 1 : -1;
}
}
const Int_t kMAXBIN=kMAXZ*(npads+2);
AliBin *bins=new AliBin[kMAXBIN];
for (Int_t ii=0;ii<kMAXBIN;ii++) {
bins[ii].SetQ(0); bins[ii].SetMask(0xFFFFFFFE);
}
digarr.First();
do {
Short_t dig=digarr.CurrentDigit();
if (dig<=par->GetZeroSup()) continue;
Int_t j=digarr.CurrentRow()+1, i=digarr.CurrentColumn()+1;
bins[i*kMAXZ+j].SetQ(dig);
bins[i*kMAXZ+j].SetMask(1);
} while (digarr.Next());
Int_t ncl=0;
for (Int_t i=0; i<kMAXBIN; i++) {
if ((bins[i].GetMask()&1) == 0) continue;
Int_t idx[32]; UInt_t msk[32]; Int_t npeaks=0;
FindPeaks(i, kMAXZ, bins, idx, msk, npeaks);
if (npeaks>30) continue;
Int_t k,l;
for (k=0; k<npeaks-1; k++){//mark adjacent peaks
if (idx[k] < 0) continue; //this peak is already removed
for (l=k+1; l<npeaks; l++) {
if (idx[l] < 0) continue; //this peak is already removed
Int_t ki=idx[k]/kMAXZ, kj=idx[k] - ki*kMAXZ;
Int_t li=idx[l]/kMAXZ, lj=idx[l] - li*kMAXZ;
Int_t di=TMath::Abs(ki - li);
Int_t dj=TMath::Abs(kj - lj);
if (di>1 || dj>1) continue;
if (bins[idx[k]].GetQ() > bins[idx[l]].GetQ()) {
msk[l]=msk[k];
idx[l]*=-1;
} else {
msk[k]=msk[l];
idx[k]*=-1;
break;
}
}
}
for (k=0; k<npeaks; k++) {
MarkPeak(TMath::Abs(idx[k]), kMAXZ, bins, msk[k]);
}
for (k=0; k<npeaks; k++) {
if (idx[k] < 0) continue; //removed peak
AliTPCcluster c;
MakeCluster(idx[k], kMAXZ, bins, msk[k], c);
if (c.GetQ() < 5) continue; //noise cluster
c.SetY(c.GetY()/c.GetQ());
c.SetZ(c.GetZ()/c.GetQ());
Float_t s2 = c.GetSigmaY2()/c.GetQ() - c.GetY()*c.GetY();
Float_t w=par->GetPadPitchWidth(sec);
c.SetSigmaY2((s2 + 1./12.)*w*w);
if (s2 != 0.) {
c.SetSigmaY2(c.GetSigmaY2()*0.108);
if (sec<par->GetNInnerSector()) c.SetSigmaY2(c.GetSigmaY2()*2.07);
}
s2 = c.GetSigmaZ2()/c.GetQ() - c.GetZ()*c.GetZ();
w=par->GetZWidth();
c.SetSigmaZ2((s2 + 1./12.)*w*w);
if (s2 != 0.) {
c.SetSigmaZ2(c.GetSigmaZ2()*0.169);
if (sec<par->GetNInnerSector()) c.SetSigmaZ2(c.GetSigmaZ2()*1.77);
}
c.SetY((c.GetY() - 0.5 - 0.5*npads)*par->GetPadPitchWidth(sec));
c.SetZ(par->GetZWidth()*(c.GetZ()-1));
c.SetZ(c.GetZ() - 3.*par->GetZSigma()); // PASA delay
c.SetZ(sign*(par->GetZLength() - c.GetZ()));
if (rx<230./250.*TMath::Abs(c.GetZ())) continue;
Int_t ki=idx[k]/kMAXZ, kj=idx[k] - ki*kMAXZ;
c.SetLabel(digarr.GetTrackID(kj-1,ki-1,0),0);
c.SetLabel(digarr.GetTrackID(kj-1,ki-1,1),1);
c.SetLabel(digarr.GetTrackID(kj-1,ki-1,2),2);
c.SetQ(bins[idx[k]].GetQ());
if (ki==1 || ki==npads || kj==1 || kj==kMAXZ-2) {
c.SetSigmaY2(c.GetSigmaY2()*25.);
c.SetSigmaZ2(c.GetSigmaZ2()*4.);
}
clrow->InsertCluster(&c); ncl++;
}
}
carray.StoreRow(sec,row);
carray.ClearRow(sec,row);
//cerr<<"sector, row, compressed digits, clusters: "
//<<sec<<' '<<row<<' '<<digarr.GetSize()<<' '<<ncl<<" \r";
nclusters+=ncl;
delete[] bins;
}
cerr<<"Number of found clusters : "<<nclusters<<" \n";
carray.GetTree()->SetName(cname);
carray.GetTree()->Write();
savedir->cd();
delete t; //Thanks to Mariana Bondila
}
|
/*
@file
@author Calvin Tee (collectskin.com)
@author Sudarshan S. Chawathe (eip10.org)
@version 0.1
@section License
BSD; see comments in main source files for details.
@section Description
A FUSE-based filesystem using the Android ADB interface.
@mainpage
adbFS: A FUSE-based filesystem using the Android ADB interface.
Usage: To mount use
@code adbfs mountpoint @endcode
where mountpoint is a suitable directory. To unmount, use
@code fusermount -u mountpoint @endcode
as usual for FUSE.
The above assumes you have a fairly standard Android development
setup, with adb in the path, busybox available on the Android
device, etc. Everything is very lightly tested and a work in
progress. Read the source and use with caution.
*/
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2010-2011, Calvin Tee (collectskin.com)
*
* 2011-12-25 Updated by Sudarshan S. Chawathe (chaw@eip10.org).
* Fixed some problems due to filenames with spaces.
* Added comments and miscellaneous small changes.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of the nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define FUSE_USE_VERSION 26
#include "utils.h"
#include <execinfo.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
void handler(int sig) {
void *array[10];
size_t size;
// get void*'s for all entries on the stack
size = backtrace(array, 10);
// print out all the frames to stderr
fprintf(stderr, "Error: signal %d:\n", sig);
backtrace_symbols_fd(array, size, 2);
exit(1);
}
using namespace std;
void shell_escape_command(string&);
void adb_shell_escape_command(string&);
queue<string> adb_push(const string&, const string&);
queue<string> adb_pull(const string&, const string&);
queue<string> adb_shell(const string&);
queue<string> shell(const string&);
string tempDirPath;
map<string,fileCache> fileData;
void invalidateCache(const string& path) {
cout << "invalidate cache " << path << endl;
map<string, fileCache>::iterator it = fileData.find(path);
if (it != fileData.end())
fileData.erase(it);
}
map<int,bool> filePendingWrite;
map<string,bool> fileTruncated;
/**
Return the result of executing the given command string, using
exec_command, on the local host.
@param command the command to execute.
@see exec_command.
*/
queue<string> shell(const string& command)
{
string actual_command;
actual_command.assign(command);
//shell_escape_command(actual_command);
return exec_command(actual_command);
}
/**
Return the result of executing the given command on the Android
device using adb.
The given string command is prefixed with "adb shell busybox " to
yield the adb command line.
@param command the command to execute.
@see exec_command.
@todo perhaps avoid use of local shell to simplify escaping.
*/
queue<string> adb_shell(const string& command)
{
string actual_command;
actual_command.assign(command);
//adb_shell_escape_command(actual_command);
actual_command.insert(0, "adb shell ");
return exec_command(actual_command);
}
/**
Modify, in place, the given string by escaping characters that are
special to the shell.
@param cmd the string to be escaped.
@see adb_shell_escape_command.
@todo check/simplify escaping.
*/
void shell_escape_command(string& cmd)
{
string_replacer(cmd,"\\","\\\\");
string_replacer(cmd,"'","\\'");
string_replacer(cmd,"`","\\`");
}
/**
Modify, in place, the given string by escaping characters that are
special to the adb shell.
@param cmd the string to be escaped.
@see shell_escape_command.
@todo check/simplify escaping.
*/
void adb_shell_escape_command(string& cmd)
{
string_replacer(cmd,"\\","\\\\");
string_replacer(cmd,"(","\\(");
string_replacer(cmd,")","\\)");
string_replacer(cmd,"'","\\'");
string_replacer(cmd,"`","\\`");
string_replacer(cmd,"|","\\|");
string_replacer(cmd,"&","\\&");
string_replacer(cmd,";","\\;");
string_replacer(cmd,"<","\\<");
string_replacer(cmd,">","\\>");
string_replacer(cmd,"*","\\*");
string_replacer(cmd,"#","\\#");
string_replacer(cmd,"%","\\%");
string_replacer(cmd,"=","\\=");
string_replacer(cmd,"~","\\~");
string_replacer(cmd,"/[0;0m","");
string_replacer(cmd,"/[1;32m","");
string_replacer(cmd,"/[1;34m","");
string_replacer(cmd,"/[1;36m","");
}
/**
Modify, in place, the given path string by escaping special characters.
@param path the string to modify.
@see shell_escape_command.
@todo check/simplify escaping.
*/
void shell_escape_path(string &path)
{
string_replacer(path, "'", "'\\''");
}
/**
Make a secure temporary directory for each mounted filesystem. Use with
ANDROID_SERIAL environment variable to mount multiple phones at once.
Also set up a callback to cleanup after ourselves on clean shutdown.
*/
void cleanupTmpDir(void) {
string command = "rm -rf ";
command.append(tempDirPath);
shell(command);
}
void makeTmpDir(void) {
char adbfsTemplate[]="/tmp/adbfs-XXXXXX";
tempDirPath.assign(mkdtemp(adbfsTemplate));
tempDirPath.append("/");
atexit(&cleanupTmpDir);
}
/**
Set a given string to an adb push or pull command with given paths.
@param cmd string to which the adb command is written.
@param push true for a push command, false for pull.
@param local_path path on local host for push or pull command.
@param remote_path path on remote device for push or pull command.
@see adb_pull.
@see adb_push.
*/
void adb_push_pull_cmd(string& cmd, const bool push,
const string& local_path, const string& remote_path)
{
cmd.assign("adb ");
cmd.append((push ? "push '" : "pull '"));
cmd.append((push ? local_path : remote_path));
cmd.append("' '");
cmd.append((push ? remote_path : local_path));
cmd.append("'");
}
/**
Copy (using adb pull) a file from the Android device to the local
host.
@param remote_source Android-side file path to copy.
@param local_destination local host-side destination path for copy.
@return result of the "adb pull ..." executed using exec_command.
@see adb_push.
@see adb_push_pull_cmd.
@todo perhaps avoid or simplify shell-escaping.
@bug problems with files with spaces in filenames (adb bug?)
*/
queue<string> adb_pull(const string& remote_source,
const string& local_destination)
{
string cmd;
adb_push_pull_cmd(cmd, false, local_destination, remote_source);
return exec_command(cmd);
}
/**
Copy (using adb push) a file from the local host to the Android
device. Very similar to adb_pull.
@see adb_pull.
@see adb_push_pull_cmd.
@bug problems with files with spaces in filenames (adb bug?)
*/
queue<string> adb_push(const string& local_source,
const string& remote_destination)
{
string cmd;
adb_push_pull_cmd(cmd, true, local_source, remote_destination);
queue<string> res = exec_command(cmd);
invalidateCache(remote_destination);
return res;
}
/**
adbFS implementation of FUSE interface function fuse_operations.getattr.
@todo check shell escaping.
*/
int strmode_to_rawmode(const string& str) {
int fmode = 0;
switch (str[0]) {
case 's': fmode |= S_IFSOCK; break;
case 'l': fmode |= S_IFLNK; break;
case '-': fmode |= S_IFREG; break;
case 'd': fmode |= S_IFDIR; break;
case 'b': fmode |= S_IFBLK; break;
case 'c': fmode |= S_IFCHR; break;
case 'p': fmode |= S_IFIFO; break;
}
if (str[1] == 'r') fmode |= S_IRUSR;
if (str[2] == 'w') fmode |= S_IWUSR;
switch (str[3]) {
case 'x': fmode |= S_IXUSR; break;
case 's': fmode |= S_ISUID | S_IXUSR; break;
case 'S': fmode |= S_ISUID; break;
}
if (str[4] == 'r') fmode |= S_IRGRP;
if (str[5] == 'w') fmode |= S_IWGRP;
switch (str[6]) {
case 'x': fmode |= S_IXGRP; break;
case 's': fmode |= S_ISGID | S_IXGRP; break;
case 'S': fmode |= S_ISGID; break;
}
if (str[7] == 'r') fmode |= S_IROTH;
if (str[8] == 'w') fmode |= S_IWOTH;
switch (str[9]) {
case 'x': fmode |= S_IXOTH; break;
case 't': fmode |= S_ISVTX | S_IXOTH; break;
case 'T': fmode |= S_ISVTX; break;
}
return fmode;
// In octal,
// // 40XXX is folder, 100xxx is file
// // xxx is regular mode e.g. 755 = -rwxr-xr-x
//
}
static int adb_getattr(const char *path, struct stat *stbuf)
{
int res = 0;
struct passwd * foruid;
struct group * forgid;
memset(stbuf, 0, sizeof(struct stat));
queue<string> output;
string path_string;
path_string.assign(path);
shell_escape_path(path_string);
// TODO /caching?
//
vector<string> output_chunk;
if (fileData.find(path_string) == fileData.end()
|| fileData[path_string].timestamp + 30 < time(NULL)) {
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
output = adb_shell(command);
if (output.empty()) return -EAGAIN; /* no phone */
output_chunk = make_array(output.front());
fileData[path_string].statOutput = output.front();
fileData[path_string].timestamp = time(NULL);
} else{
output_chunk = make_array(fileData[path_string].statOutput);
cout << "from cache " << path << "\n";
}
if (output_chunk[0][0] == '/'){
return -ENOENT;
}
/*
stat -t Explained:
file name (%n)
total size (%s)
number of blocks (%b)
raw mode in hex (%f)
UID of owner (%u)
GID of file (%g)
device number in hex (%D)
inode number (%i)
number of hard links (%h)
major devide type in hex (%t)
minor device type in hex (%T)
last access time as seconds since the Unix Epoch (%X)
last modification as seconds since the Unix Epoch (%Y)
last change as seconds since the Unix Epoch (%Z)
I/O block size (%o)
*/
//
// ls -lad explained
// -rw-rw-r-- root sdcard_rw 763362 2012-06-22 02:16 fajlot.html
//
//stbuf->st_dev = atoi(output_chunk[1].c_str()); /* ID of device containing file */
//
// In octal,
// 40XXX is folder, 100xxx is file
// xxx is regular mode e.g. 755 = rwxr-xr-x
//
stbuf->st_ino = 1; // atoi(output_chunk[7].c_str()); /* inode number */
//stbuf->st_mode = raw_mode | 0700; /* protection */
stbuf->st_mode = strmode_to_rawmode(output_chunk[0]);
stbuf->st_nlink = 1; /* number of hard links */
foruid = getpwnam(output_chunk[1].c_str());
if (foruid)
stbuf->st_uid = foruid->pw_uid; /* user ID of owner */
else
stbuf->st_uid = 98; /* 98 has been chosen (poorly) so that it doesn't map to anything */
forgid = getgrnam(output_chunk[2].c_str());
if (forgid)
stbuf->st_gid = forgid->gr_gid; /* group ID of owner */
else
stbuf->st_gid = 98;
//unsigned int device_id;
//xtoi(output_chunk[6].c_str(),&device_id);
//stbuf->st_rdev = device_id; // device ID (if special file)
int iDate;
switch (stbuf->st_mode & S_IFMT) {
case S_IFBLK:
case S_IFCHR:
stbuf->st_rdev = atoi(output_chunk[3].c_str()) * 256 + atoi(output_chunk[4].c_str());
stbuf->st_size = 0;
iDate = 5;
break;
break;
case S_IFREG:
stbuf->st_size = atoi(output_chunk[3].c_str()); /* total size, in bytes */
iDate = 4;
break;
default:
case S_IFSOCK:
case S_IFIFO:
case S_IFLNK:
case S_IFDIR:
stbuf->st_size = 0;
iDate = 3;
break;
}
stbuf->st_blksize = 0; // TODO: THIS IS SMELLY
stbuf->st_blocks = 1;
//for (int k = 0; k < output_chunk.size(); ++k) cout << output_chunk[k] << " ";
//cout << endl;
vector<string> ymd = make_array(output_chunk[iDate], "-");
vector<string> hm = make_array(output_chunk[iDate + 1], ":");
//for (int k = 0; k < ymd.size(); ++k) cout << ymd[k] << " ";
//cout << endl;
//for (int k = 0; k < hm.size(); ++k) cout << hm[k] << " ";
//cout << endl;
struct tm ftime;
ftime.tm_year = atoi(ymd[0].c_str()) - 1900;
ftime.tm_mon = atoi(ymd[1].c_str()) - 1;
ftime.tm_mday = atoi(ymd[2].c_str());
ftime.tm_hour = atoi(hm[0].c_str());
ftime.tm_min = atoi(hm[1].c_str());
ftime.tm_sec = 0;
ftime.tm_isdst = -1;
time_t now = mktime(&ftime);
//cout << "after mktime" << endl;
//long now = time(0);
stbuf->st_atime = now; /* time of last access */
//stbuf->st_atime = atol(output_chunk[11].c_str()); /* time of last access */
stbuf->st_mtime = now; /* time of last modification */
//stbuf->st_mtime = atol(output_chunk[12].c_str()); /* time of last modification */
stbuf->st_ctime = now; /* time of last status change */
//stbuf->st_ctime = atol(output_chunk[13].c_str()); /* time of last status change */
return res;
}
size_t find_nth(int n, const string& substr, const string& corpus) {
size_t p = 0;
while (n--) {
if ((( p = corpus.find_first_of(substr, p) )) == string::npos) return string::npos;
p = corpus.find_first_not_of(substr, p);
}
return p;
}
/**
adbFS implementation of FUSE interface function fuse_operations.readdir.
@todo check shell escaping.
*/
static int adb_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
(void) offset;
(void) fi;
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
queue<string> output;
string command = "ls -l -a '";
command.append(path_string);
command.append("'");
output = adb_shell(command);
if (!output.size()) return 0;
/* cannot tell between "no phone" and "empty directory" */
vector<string> output_chunk = make_array(output.front());
/* The specific error messages we are looking for (from the android source)-
(in listdir) "opendir failed, strerror"
(in show_total_size) "stat failed on filename, strerror"
(in listfile_size) "lstat 'filename' failed: strerror"
Thus, we can abuse this a little and just make sure that the second
character is either "r" or "-", and assume it's an error otherwise.
It'd be really nice if we could actually take the strerrors and convert
them back to codes, but I fear that involves undoing localization.
*/
if (output.front().length() < 3) return -ENOENT;
if (output.front().c_str()[1] != 'r' &&
output.front().c_str()[1] != '-') return -ENOENT;
while (output.size() > 0) {
const string& fname_l_t = output.front().substr(54);
const string& fname_l = fname_l_t.substr(find_nth(1, " ",fname_l_t));
const string& fname_n = fname_l.substr(0, fname_l.find(" -> "));
filler(buf, fname_n.c_str(), NULL, 0);
const string& path_string_c = path_string
+ (path_string == "/" ? "" : "/") + fname_n;
cout << "caching " << path_string_c << " = " << output.front() << endl;
fileData[path_string_c].statOutput = output.front();
fileData[path_string_c].timestamp = time(NULL);
cout << "cached " << endl;
output.pop();
}
return 0;
}
static int adb_open(const char *path, struct fuse_file_info *fi)
{
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
string filehandle_path = local_path_string;
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
cout << "-- adb_open --" << path_string << " " << local_path_string << "\n";
if (!fileTruncated[path_string]){
queue<string> output;
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
cout << command<<"\n";
output = adb_shell(command);
vector<string> output_chunk = make_array(output.front());
if (output_chunk[0][0] == '/') {
return -ENOENT;
}
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
adb_pull(path_string,local_path_string);
} else {
fileTruncated[path_string] = false;
}
fi->fh = open(filehandle_path.c_str(), fi->flags);
return 0;
}
static int adb_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
int fd;
int res;
fd = fi->fh; //open(local_path_string.c_str(), O_RDWR);
if(fd == -1)
return -errno;
res = pread(fd, buf, size, offset);
//close(fd);
if(res == -1)
res = -errno;
return size;
}
static int adb_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
//string path_string;
//string local_path_string;
//path_string.assign(path);
//shell_escape_path(path_string);
int fd = fi->fh; //open(local_path_string.c_str(), O_CREAT|O_RDWR|O_TRUNC);
filePendingWrite[fd] = true;
int res = pwrite(fd, buf, size, offset);
//close(fd);
//adb_push(local_path_string,path_string);
//adb_shell("sync");
if (res == -1)
res = -errno;
return res;
}
static int adb_flush(const char *path, struct fuse_file_info *fi) {
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
int flags = fi->flags;
int fd = fi->fh;
cout << "flag is: "<< flags <<"\n";
invalidateCache(path_string);
if (filePendingWrite[fd]) {
filePendingWrite[fd] = false;
adb_push(local_path_string, path_string);
adb_shell("sync");
}
return 0;
}
static int adb_release(const char *path, struct fuse_file_info *fi) {
int fd = fi->fh;
filePendingWrite.erase(filePendingWrite.find(fd));
close(fd);
return 0;
}
static int adb_access(const char *path, int mask) {
//###cout << "###access[path=" << path << "]" << endl;
return 0;
}
static int adb_utimens(const char *path, const struct timespec ts[2]) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
queue<string> output;
string command = "touch '";
command.append(path_string);
command.append("'");
cout << command<<"\n";
adb_shell(command);
return 0;
}
static int adb_truncate(const char *path, off_t size) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
queue<string> output;
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
cout << command << "\n";
output = adb_shell(command);
vector<string> output_chunk = make_array(output.front());
if (output_chunk[0][0] == '/'){
adb_pull(path_string,local_path_string);
}
fileTruncated[path_string] = true;
invalidateCache(path_string);
cout << "truncate[path=" << local_path_string << "][size=" << size << "]" << endl;
return truncate(local_path_string.c_str(),size);
}
static int adb_mknod(const char *path, mode_t mode, dev_t rdev) {
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
cout << "mknod for " << local_path_string << "\n";
mknod(local_path_string.c_str(),mode, rdev);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
adb_push(local_path_string,path_string);
adb_shell("sync");
invalidateCache(path_string);
return 0;
}
static int adb_mkdir(const char *path, mode_t mode) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
string command;
command.assign("mkdir '");
command.append(path_string);
command.append("'");
adb_shell(command);
invalidateCache(path_string);
return 0;
}
static int adb_rename(const char *from, const char *to) {
string local_from_string,local_to_string = tempDirPath;
string from_string = string(from), to_string = string(to);
local_from_string.append(from);
local_to_string.append(to);
shell_escape_path(local_from_string);
shell_escape_path(local_to_string);
shell_escape_path(from_string);
shell_escape_path(to_string);
string command = "mv '";
command.append(from_string);
command.append("' '");
command.append(to_string);
command.append("'");
cout << "Renaming " << from << " to " << to <<"\n";
adb_shell(command);
invalidateCache(string(from));
invalidateCache(string(to));
return 0;
}
static int adb_rmdir(const char *path) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
string command = "rm -r '";
command.append(path_string);
command.append("'");
adb_shell(command);
invalidateCache(path_string);
//rmdir(local_path_string.c_str());
return 0;
}
static int adb_unlink(const char *path) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
string command = "rm '";
command.append(path_string);
command.append("'");
adb_shell(command);
invalidateCache(path_string);
unlink(local_path_string.c_str());
return 0;
}
static int adb_readlink(const char *path, char *buf, size_t size)
{
string path_string(path);
shell_escape_path(path_string);
queue<string> output;
string res;
// get the number of slashes in the path
int num_slashes, ii;
for (num_slashes = ii = 0; ii < strlen(path); ii++)
if (path[ii] == '/')
num_slashes++;
if (num_slashes >= 1) num_slashes--;
if (fileData.find(path_string) == fileData.end()
|| fileData[path_string].timestamp + 30 < time(NULL)) {
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
output = adb_shell(command);
if (output.empty())
return -EINVAL;
res = output.front();
fileData[path_string].statOutput = output.front();
fileData[path_string].timestamp = time(NULL);
} else{
res = fileData[path_string].statOutput;
cout << "from cache " << path << "\n";
}
if (res[0] == '/'){
return -ENOENT;
}
cout << "adb_readlink " << res << endl;
size_t pos = res.find(" -> ");
if(pos == string::npos)
return -EINVAL;
pos+=4;
size_t my_size = res.size();
buf[0] = 0;
if (res[pos] == '/') {
while(res[pos] == '/')
++pos;
my_size += 3 * num_slashes - pos;
if(my_size >= size)
return -ENOSYS;
for (;num_slashes;num_slashes--) {
strncat(buf,"../",size);
}
}
if(my_size >= size)
return -ENOSYS;
strncat(buf, res.c_str() + pos,size);
return 0;
}
/**
Main struct for FUSE interface.
*/
static struct fuse_operations adbfs_oper;
/**
Set up the fuse_operations struct adbfs_oper using above adb_*
functions and then call fuse_main to manage things.
@see fuse_main in fuse.h.
*/
int main(int argc, char *argv[])
{
signal(SIGSEGV, handler); // install our handler
makeTmpDir();
memset(&adbfs_oper, sizeof(adbfs_oper), 0);
adbfs_oper.readdir= adb_readdir;
adbfs_oper.getattr= adb_getattr;
adbfs_oper.access= adb_access;
adbfs_oper.open= adb_open;
adbfs_oper.flush = adb_flush;
adbfs_oper.release = adb_release;
adbfs_oper.read= adb_read;
adbfs_oper.write = adb_write;
adbfs_oper.utimens = adb_utimens;
adbfs_oper.truncate = adb_truncate;
adbfs_oper.mknod = adb_mknod;
adbfs_oper.mkdir = adb_mkdir;
adbfs_oper.rename = adb_rename;
adbfs_oper.rmdir = adb_rmdir;
adbfs_oper.unlink = adb_unlink;
adbfs_oper.readlink = adb_readlink;
adb_shell("ls");
return fuse_main(argc, argv, &adbfs_oper, NULL);
}
dont rely on fixed width column output of ls
/*
@file
@author Calvin Tee (collectskin.com)
@author Sudarshan S. Chawathe (eip10.org)
@version 0.1
@section License
BSD; see comments in main source files for details.
@section Description
A FUSE-based filesystem using the Android ADB interface.
@mainpage
adbFS: A FUSE-based filesystem using the Android ADB interface.
Usage: To mount use
@code adbfs mountpoint @endcode
where mountpoint is a suitable directory. To unmount, use
@code fusermount -u mountpoint @endcode
as usual for FUSE.
The above assumes you have a fairly standard Android development
setup, with adb in the path, busybox available on the Android
device, etc. Everything is very lightly tested and a work in
progress. Read the source and use with caution.
*/
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2010-2011, Calvin Tee (collectskin.com)
*
* 2011-12-25 Updated by Sudarshan S. Chawathe (chaw@eip10.org).
* Fixed some problems due to filenames with spaces.
* Added comments and miscellaneous small changes.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of the nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define FUSE_USE_VERSION 26
#include "utils.h"
#include <execinfo.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
void handler(int sig) {
void *array[10];
size_t size;
// get void*'s for all entries on the stack
size = backtrace(array, 10);
// print out all the frames to stderr
fprintf(stderr, "Error: signal %d:\n", sig);
backtrace_symbols_fd(array, size, 2);
exit(1);
}
using namespace std;
void shell_escape_command(string&);
void adb_shell_escape_command(string&);
queue<string> adb_push(const string&, const string&);
queue<string> adb_pull(const string&, const string&);
queue<string> adb_shell(const string&);
queue<string> shell(const string&);
string tempDirPath;
map<string,fileCache> fileData;
void invalidateCache(const string& path) {
cout << "invalidate cache " << path << endl;
map<string, fileCache>::iterator it = fileData.find(path);
if (it != fileData.end())
fileData.erase(it);
}
map<int,bool> filePendingWrite;
map<string,bool> fileTruncated;
/**
Return the result of executing the given command string, using
exec_command, on the local host.
@param command the command to execute.
@see exec_command.
*/
queue<string> shell(const string& command)
{
string actual_command;
actual_command.assign(command);
//shell_escape_command(actual_command);
return exec_command(actual_command);
}
/**
Return the result of executing the given command on the Android
device using adb.
The given string command is prefixed with "adb shell busybox " to
yield the adb command line.
@param command the command to execute.
@see exec_command.
@todo perhaps avoid use of local shell to simplify escaping.
*/
queue<string> adb_shell(const string& command)
{
string actual_command;
actual_command.assign(command);
//adb_shell_escape_command(actual_command);
actual_command.insert(0, "adb shell ");
return exec_command(actual_command);
}
/**
Modify, in place, the given string by escaping characters that are
special to the shell.
@param cmd the string to be escaped.
@see adb_shell_escape_command.
@todo check/simplify escaping.
*/
void shell_escape_command(string& cmd)
{
string_replacer(cmd,"\\","\\\\");
string_replacer(cmd,"'","\\'");
string_replacer(cmd,"`","\\`");
}
/**
Modify, in place, the given string by escaping characters that are
special to the adb shell.
@param cmd the string to be escaped.
@see shell_escape_command.
@todo check/simplify escaping.
*/
void adb_shell_escape_command(string& cmd)
{
string_replacer(cmd,"\\","\\\\");
string_replacer(cmd,"(","\\(");
string_replacer(cmd,")","\\)");
string_replacer(cmd,"'","\\'");
string_replacer(cmd,"`","\\`");
string_replacer(cmd,"|","\\|");
string_replacer(cmd,"&","\\&");
string_replacer(cmd,";","\\;");
string_replacer(cmd,"<","\\<");
string_replacer(cmd,">","\\>");
string_replacer(cmd,"*","\\*");
string_replacer(cmd,"#","\\#");
string_replacer(cmd,"%","\\%");
string_replacer(cmd,"=","\\=");
string_replacer(cmd,"~","\\~");
string_replacer(cmd,"/[0;0m","");
string_replacer(cmd,"/[1;32m","");
string_replacer(cmd,"/[1;34m","");
string_replacer(cmd,"/[1;36m","");
}
/**
Modify, in place, the given path string by escaping special characters.
@param path the string to modify.
@see shell_escape_command.
@todo check/simplify escaping.
*/
void shell_escape_path(string &path)
{
string_replacer(path, "'", "'\\''");
}
/**
Make a secure temporary directory for each mounted filesystem. Use with
ANDROID_SERIAL environment variable to mount multiple phones at once.
Also set up a callback to cleanup after ourselves on clean shutdown.
*/
void cleanupTmpDir(void) {
string command = "rm -rf ";
command.append(tempDirPath);
shell(command);
}
void makeTmpDir(void) {
char adbfsTemplate[]="/tmp/adbfs-XXXXXX";
tempDirPath.assign(mkdtemp(adbfsTemplate));
tempDirPath.append("/");
atexit(&cleanupTmpDir);
}
/**
Set a given string to an adb push or pull command with given paths.
@param cmd string to which the adb command is written.
@param push true for a push command, false for pull.
@param local_path path on local host for push or pull command.
@param remote_path path on remote device for push or pull command.
@see adb_pull.
@see adb_push.
*/
void adb_push_pull_cmd(string& cmd, const bool push,
const string& local_path, const string& remote_path)
{
cmd.assign("adb ");
cmd.append((push ? "push '" : "pull '"));
cmd.append((push ? local_path : remote_path));
cmd.append("' '");
cmd.append((push ? remote_path : local_path));
cmd.append("'");
}
/**
Copy (using adb pull) a file from the Android device to the local
host.
@param remote_source Android-side file path to copy.
@param local_destination local host-side destination path for copy.
@return result of the "adb pull ..." executed using exec_command.
@see adb_push.
@see adb_push_pull_cmd.
@todo perhaps avoid or simplify shell-escaping.
@bug problems with files with spaces in filenames (adb bug?)
*/
queue<string> adb_pull(const string& remote_source,
const string& local_destination)
{
string cmd;
adb_push_pull_cmd(cmd, false, local_destination, remote_source);
return exec_command(cmd);
}
/**
Copy (using adb push) a file from the local host to the Android
device. Very similar to adb_pull.
@see adb_pull.
@see adb_push_pull_cmd.
@bug problems with files with spaces in filenames (adb bug?)
*/
queue<string> adb_push(const string& local_source,
const string& remote_destination)
{
string cmd;
adb_push_pull_cmd(cmd, true, local_source, remote_destination);
queue<string> res = exec_command(cmd);
invalidateCache(remote_destination);
return res;
}
/**
adbFS implementation of FUSE interface function fuse_operations.getattr.
@todo check shell escaping.
*/
int strmode_to_rawmode(const string& str) {
int fmode = 0;
switch (str[0]) {
case 's': fmode |= S_IFSOCK; break;
case 'l': fmode |= S_IFLNK; break;
case '-': fmode |= S_IFREG; break;
case 'd': fmode |= S_IFDIR; break;
case 'b': fmode |= S_IFBLK; break;
case 'c': fmode |= S_IFCHR; break;
case 'p': fmode |= S_IFIFO; break;
}
if (str[1] == 'r') fmode |= S_IRUSR;
if (str[2] == 'w') fmode |= S_IWUSR;
switch (str[3]) {
case 'x': fmode |= S_IXUSR; break;
case 's': fmode |= S_ISUID | S_IXUSR; break;
case 'S': fmode |= S_ISUID; break;
}
if (str[4] == 'r') fmode |= S_IRGRP;
if (str[5] == 'w') fmode |= S_IWGRP;
switch (str[6]) {
case 'x': fmode |= S_IXGRP; break;
case 's': fmode |= S_ISGID | S_IXGRP; break;
case 'S': fmode |= S_ISGID; break;
}
if (str[7] == 'r') fmode |= S_IROTH;
if (str[8] == 'w') fmode |= S_IWOTH;
switch (str[9]) {
case 'x': fmode |= S_IXOTH; break;
case 't': fmode |= S_ISVTX | S_IXOTH; break;
case 'T': fmode |= S_ISVTX; break;
}
return fmode;
// In octal,
// // 40XXX is folder, 100xxx is file
// // xxx is regular mode e.g. 755 = -rwxr-xr-x
//
}
static int adb_getattr(const char *path, struct stat *stbuf)
{
int res = 0;
struct passwd * foruid;
struct group * forgid;
memset(stbuf, 0, sizeof(struct stat));
queue<string> output;
string path_string;
path_string.assign(path);
shell_escape_path(path_string);
// TODO /caching?
//
vector<string> output_chunk;
if (fileData.find(path_string) == fileData.end()
|| fileData[path_string].timestamp + 30 < time(NULL)) {
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
output = adb_shell(command);
if (output.empty()) return -EAGAIN; /* no phone */
output_chunk = make_array(output.front());
fileData[path_string].statOutput = output.front();
fileData[path_string].timestamp = time(NULL);
} else{
output_chunk = make_array(fileData[path_string].statOutput);
cout << "from cache " << path << "\n";
}
if (output_chunk[0][0] == '/'){
return -ENOENT;
}
/*
stat -t Explained:
file name (%n)
total size (%s)
number of blocks (%b)
raw mode in hex (%f)
UID of owner (%u)
GID of file (%g)
device number in hex (%D)
inode number (%i)
number of hard links (%h)
major devide type in hex (%t)
minor device type in hex (%T)
last access time as seconds since the Unix Epoch (%X)
last modification as seconds since the Unix Epoch (%Y)
last change as seconds since the Unix Epoch (%Z)
I/O block size (%o)
*/
//
// ls -lad explained
// -rw-rw-r-- root sdcard_rw 763362 2012-06-22 02:16 fajlot.html
//
//stbuf->st_dev = atoi(output_chunk[1].c_str()); /* ID of device containing file */
//
// In octal,
// 40XXX is folder, 100xxx is file
// xxx is regular mode e.g. 755 = rwxr-xr-x
//
stbuf->st_ino = 1; // atoi(output_chunk[7].c_str()); /* inode number */
//stbuf->st_mode = raw_mode | 0700; /* protection */
stbuf->st_mode = strmode_to_rawmode(output_chunk[0]);
stbuf->st_nlink = 1; /* number of hard links */
foruid = getpwnam(output_chunk[1].c_str());
if (foruid)
stbuf->st_uid = foruid->pw_uid; /* user ID of owner */
else
stbuf->st_uid = 98; /* 98 has been chosen (poorly) so that it doesn't map to anything */
forgid = getgrnam(output_chunk[2].c_str());
if (forgid)
stbuf->st_gid = forgid->gr_gid; /* group ID of owner */
else
stbuf->st_gid = 98;
//unsigned int device_id;
//xtoi(output_chunk[6].c_str(),&device_id);
//stbuf->st_rdev = device_id; // device ID (if special file)
int iDate;
switch (stbuf->st_mode & S_IFMT) {
case S_IFBLK:
case S_IFCHR:
stbuf->st_rdev = atoi(output_chunk[3].c_str()) * 256 + atoi(output_chunk[4].c_str());
stbuf->st_size = 0;
iDate = 5;
break;
break;
case S_IFREG:
stbuf->st_size = atoi(output_chunk[3].c_str()); /* total size, in bytes */
iDate = 4;
break;
default:
case S_IFSOCK:
case S_IFIFO:
case S_IFLNK:
case S_IFDIR:
stbuf->st_size = 0;
iDate = 3;
break;
}
stbuf->st_blksize = 0; // TODO: THIS IS SMELLY
stbuf->st_blocks = 1;
//for (int k = 0; k < output_chunk.size(); ++k) cout << output_chunk[k] << " ";
//cout << endl;
vector<string> ymd = make_array(output_chunk[iDate], "-");
vector<string> hm = make_array(output_chunk[iDate + 1], ":");
//for (int k = 0; k < ymd.size(); ++k) cout << ymd[k] << " ";
//cout << endl;
//for (int k = 0; k < hm.size(); ++k) cout << hm[k] << " ";
//cout << endl;
struct tm ftime;
ftime.tm_year = atoi(ymd[0].c_str()) - 1900;
ftime.tm_mon = atoi(ymd[1].c_str()) - 1;
ftime.tm_mday = atoi(ymd[2].c_str());
ftime.tm_hour = atoi(hm[0].c_str());
ftime.tm_min = atoi(hm[1].c_str());
ftime.tm_sec = 0;
ftime.tm_isdst = -1;
time_t now = mktime(&ftime);
//cout << "after mktime" << endl;
//long now = time(0);
stbuf->st_atime = now; /* time of last access */
//stbuf->st_atime = atol(output_chunk[11].c_str()); /* time of last access */
stbuf->st_mtime = now; /* time of last modification */
//stbuf->st_mtime = atol(output_chunk[12].c_str()); /* time of last modification */
stbuf->st_ctime = now; /* time of last status change */
//stbuf->st_ctime = atol(output_chunk[13].c_str()); /* time of last status change */
return res;
}
size_t find_nth(int n, const string& substr, const string& corpus) {
size_t p = 0;
while (n--) {
if ((( p = corpus.find_first_of(substr, p) )) == string::npos) return string::npos;
p = corpus.find_first_not_of(substr, p);
}
return p;
}
/**
adbFS implementation of FUSE interface function fuse_operations.readdir.
@todo check shell escaping.
*/
static int adb_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
(void) offset;
(void) fi;
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
queue<string> output;
string command = "ls -l -a '";
command.append(path_string);
command.append("'");
output = adb_shell(command);
if (!output.size()) return 0;
/* cannot tell between "no phone" and "empty directory" */
vector<string> output_chunk = make_array(output.front());
/* The specific error messages we are looking for (from the android source)-
(in listdir) "opendir failed, strerror"
(in show_total_size) "stat failed on filename, strerror"
(in listfile_size) "lstat 'filename' failed: strerror"
Thus, we can abuse this a little and just make sure that the second
character is either "r" or "-", and assume it's an error otherwise.
It'd be really nice if we could actually take the strerrors and convert
them back to codes, but I fear that involves undoing localization.
*/
if (output.front().length() < 3) return -ENOENT;
if (output.front().c_str()[1] != 'r' &&
output.front().c_str()[1] != '-') return -ENOENT;
while (output.size() > 0) {
// Start of filename = `ls -la` time separator + 3
size_t nameStart = output.front().find_first_of(":") + 3;
const string& fname_l_t = output.front().substr(nameStart);
const string& fname_l = fname_l_t.substr(find_nth(1, " ",fname_l_t));
const string& fname_n = fname_l.substr(0, fname_l.find(" -> "));
filler(buf, fname_n.c_str(), NULL, 0);
const string& path_string_c = path_string
+ (path_string == "/" ? "" : "/") + fname_n;
cout << "caching " << path_string_c << " = " << output.front() << endl;
fileData[path_string_c].statOutput = output.front();
fileData[path_string_c].timestamp = time(NULL);
cout << "cached " << endl;
output.pop();
}
return 0;
}
static int adb_open(const char *path, struct fuse_file_info *fi)
{
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
string filehandle_path = local_path_string;
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
cout << "-- adb_open --" << path_string << " " << local_path_string << "\n";
if (!fileTruncated[path_string]){
queue<string> output;
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
cout << command<<"\n";
output = adb_shell(command);
vector<string> output_chunk = make_array(output.front());
if (output_chunk[0][0] == '/') {
return -ENOENT;
}
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
adb_pull(path_string,local_path_string);
} else {
fileTruncated[path_string] = false;
}
fi->fh = open(filehandle_path.c_str(), fi->flags);
return 0;
}
static int adb_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *fi)
{
int fd;
int res;
fd = fi->fh; //open(local_path_string.c_str(), O_RDWR);
if(fd == -1)
return -errno;
res = pread(fd, buf, size, offset);
//close(fd);
if(res == -1)
res = -errno;
return size;
}
static int adb_write(const char *path, const char *buf, size_t size, off_t offset, struct fuse_file_info *fi) {
//string path_string;
//string local_path_string;
//path_string.assign(path);
//shell_escape_path(path_string);
int fd = fi->fh; //open(local_path_string.c_str(), O_CREAT|O_RDWR|O_TRUNC);
filePendingWrite[fd] = true;
int res = pwrite(fd, buf, size, offset);
//close(fd);
//adb_push(local_path_string,path_string);
//adb_shell("sync");
if (res == -1)
res = -errno;
return res;
}
static int adb_flush(const char *path, struct fuse_file_info *fi) {
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
int flags = fi->flags;
int fd = fi->fh;
cout << "flag is: "<< flags <<"\n";
invalidateCache(path_string);
if (filePendingWrite[fd]) {
filePendingWrite[fd] = false;
adb_push(local_path_string, path_string);
adb_shell("sync");
}
return 0;
}
static int adb_release(const char *path, struct fuse_file_info *fi) {
int fd = fi->fh;
filePendingWrite.erase(filePendingWrite.find(fd));
close(fd);
return 0;
}
static int adb_access(const char *path, int mask) {
//###cout << "###access[path=" << path << "]" << endl;
return 0;
}
static int adb_utimens(const char *path, const struct timespec ts[2]) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
queue<string> output;
string command = "touch '";
command.append(path_string);
command.append("'");
cout << command<<"\n";
adb_shell(command);
return 0;
}
static int adb_truncate(const char *path, off_t size) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
queue<string> output;
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
cout << command << "\n";
output = adb_shell(command);
vector<string> output_chunk = make_array(output.front());
if (output_chunk[0][0] == '/'){
adb_pull(path_string,local_path_string);
}
fileTruncated[path_string] = true;
invalidateCache(path_string);
cout << "truncate[path=" << local_path_string << "][size=" << size << "]" << endl;
return truncate(local_path_string.c_str(),size);
}
static int adb_mknod(const char *path, mode_t mode, dev_t rdev) {
string path_string;
string local_path_string;
path_string.assign(path);
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
cout << "mknod for " << local_path_string << "\n";
mknod(local_path_string.c_str(),mode, rdev);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
adb_push(local_path_string,path_string);
adb_shell("sync");
invalidateCache(path_string);
return 0;
}
static int adb_mkdir(const char *path, mode_t mode) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
string command;
command.assign("mkdir '");
command.append(path_string);
command.append("'");
adb_shell(command);
invalidateCache(path_string);
return 0;
}
static int adb_rename(const char *from, const char *to) {
string local_from_string,local_to_string = tempDirPath;
string from_string = string(from), to_string = string(to);
local_from_string.append(from);
local_to_string.append(to);
shell_escape_path(local_from_string);
shell_escape_path(local_to_string);
shell_escape_path(from_string);
shell_escape_path(to_string);
string command = "mv '";
command.append(from_string);
command.append("' '");
command.append(to_string);
command.append("'");
cout << "Renaming " << from << " to " << to <<"\n";
adb_shell(command);
invalidateCache(string(from));
invalidateCache(string(to));
return 0;
}
static int adb_rmdir(const char *path) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
string command = "rm -r '";
command.append(path_string);
command.append("'");
adb_shell(command);
invalidateCache(path_string);
//rmdir(local_path_string.c_str());
return 0;
}
static int adb_unlink(const char *path) {
string path_string;
string local_path_string;
path_string.assign(path);
fileData[path_string].timestamp = fileData[path_string].timestamp + 50;
local_path_string = tempDirPath;
string_replacer(path_string,"/","-");
local_path_string.append(path_string);
path_string.assign(path);
shell_escape_path(path_string);
shell_escape_path(local_path_string);
string command = "rm '";
command.append(path_string);
command.append("'");
adb_shell(command);
invalidateCache(path_string);
unlink(local_path_string.c_str());
return 0;
}
static int adb_readlink(const char *path, char *buf, size_t size)
{
string path_string(path);
shell_escape_path(path_string);
queue<string> output;
string res;
// get the number of slashes in the path
int num_slashes, ii;
for (num_slashes = ii = 0; ii < strlen(path); ii++)
if (path[ii] == '/')
num_slashes++;
if (num_slashes >= 1) num_slashes--;
if (fileData.find(path_string) == fileData.end()
|| fileData[path_string].timestamp + 30 < time(NULL)) {
string command = "ls -l -a -d '";
command.append(path_string);
command.append("'");
output = adb_shell(command);
if (output.empty())
return -EINVAL;
res = output.front();
fileData[path_string].statOutput = output.front();
fileData[path_string].timestamp = time(NULL);
} else{
res = fileData[path_string].statOutput;
cout << "from cache " << path << "\n";
}
if (res[0] == '/'){
return -ENOENT;
}
cout << "adb_readlink " << res << endl;
size_t pos = res.find(" -> ");
if(pos == string::npos)
return -EINVAL;
pos+=4;
size_t my_size = res.size();
buf[0] = 0;
if (res[pos] == '/') {
while(res[pos] == '/')
++pos;
my_size += 3 * num_slashes - pos;
if(my_size >= size)
return -ENOSYS;
for (;num_slashes;num_slashes--) {
strncat(buf,"../",size);
}
}
if(my_size >= size)
return -ENOSYS;
strncat(buf, res.c_str() + pos,size);
return 0;
}
/**
Main struct for FUSE interface.
*/
static struct fuse_operations adbfs_oper;
/**
Set up the fuse_operations struct adbfs_oper using above adb_*
functions and then call fuse_main to manage things.
@see fuse_main in fuse.h.
*/
int main(int argc, char *argv[])
{
signal(SIGSEGV, handler); // install our handler
makeTmpDir();
memset(&adbfs_oper, sizeof(adbfs_oper), 0);
adbfs_oper.readdir= adb_readdir;
adbfs_oper.getattr= adb_getattr;
adbfs_oper.access= adb_access;
adbfs_oper.open= adb_open;
adbfs_oper.flush = adb_flush;
adbfs_oper.release = adb_release;
adbfs_oper.read= adb_read;
adbfs_oper.write = adb_write;
adbfs_oper.utimens = adb_utimens;
adbfs_oper.truncate = adb_truncate;
adbfs_oper.mknod = adb_mknod;
adbfs_oper.mkdir = adb_mkdir;
adbfs_oper.rename = adb_rename;
adbfs_oper.rmdir = adb_rmdir;
adbfs_oper.unlink = adb_unlink;
adbfs_oper.readlink = adb_readlink;
adb_shell("ls");
return fuse_main(argc, argv, &adbfs_oper, NULL);
}
|
/*
* Copyright (C) 2015 ScyllaDB
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#include <boost/range/irange.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <seastar/net/inet_address.hh>
#include "tests/test-utils.hh"
#include "tests/cql_test_env.hh"
#include "tests/cql_assertions.hh"
#include "core/future-util.hh"
#include "core/sleep.hh"
#include "transport/messages/result_message.hh"
#include "utils/big_decimal.hh"
using namespace std::literals::chrono_literals;
SEASTAR_TEST_CASE(test_create_keyspace_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create keyspace ks2 with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };").discard_result().then([&e] {
return e.require_keyspace_exists("ks2");
});
});
}
SEASTAR_TEST_CASE(test_create_table_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table users (user_name varchar PRIMARY KEY, birth_year bigint);").discard_result().then([&e] {
return e.require_table_exists("ks", "users");
}).then([&e] {
return e.execute_cql("create table cf (id int primary key, m map<int, int>, s set<text>, l list<uuid>);").discard_result();
}).then([&e] {
return e.require_table_exists("ks", "cf");
});
});
}
SEASTAR_TEST_CASE(test_create_table_with_id_statement) {
return do_with_cql_env([](cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE tbl (a int, b int, PRIMARY KEY (a))").get();
auto id = e.local_db().find_schema("ks", "tbl")->id();
e.execute_cql("DROP TABLE tbl").get();
BOOST_REQUIRE_THROW(e.execute_cql("SELECT * FROM tbl").get(), std::exception);
e.execute_cql(
sprint("CREATE TABLE tbl (a int, b int, PRIMARY KEY (a)) WITH id='%s'", id)).get();
assert_that(e.execute_cql("SELECT * FROM tbl").get0())
.is_rows().with_size(0);
BOOST_REQUIRE_THROW(
e.execute_cql(sprint("CREATE TABLE tbl2 (a int, b int, PRIMARY KEY (a)) WITH id='%s'", id)).get(),
std::invalid_argument);
BOOST_REQUIRE_THROW(
e.execute_cql("CREATE TABLE tbl2 (a int, b int, PRIMARY KEY (a)) WITH id='55'").get(),
exceptions::configuration_exception);
BOOST_REQUIRE_THROW(
e.execute_cql("ALTER TABLE tbl WITH id='f2a8c099-e723-48cb-8cd9-53e647a011a3'").get(),
exceptions::configuration_exception);
});
});
}
SEASTAR_TEST_CASE(test_drop_table_with_si_and_mv) {
return do_with_cql_env([](cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE tbl (a int, b int, c float, PRIMARY KEY (a))").get();
e.execute_cql("CREATE INDEX idx1 ON tbl (b)").get();
e.execute_cql("CREATE INDEX idx2 ON tbl (c)").get();
e.execute_cql("CREATE MATERIALIZED VIEW tbl_view AS SELECT c FROM tbl WHERE c IS NOT NULL PRIMARY KEY (c, a)").get();
// dropping a table with materialized views is prohibited
assert_that_failed(e.execute_cql("DROP TABLE tbl"));
e.execute_cql("DROP MATERIALIZED VIEW tbl_view").get();
// dropping a table with secondary indexes is fine
e.execute_cql("DROP TABLE tbl").get();
e.execute_cql("CREATE TABLE tbl (a int, b int, c float, PRIMARY KEY (a))").get();
e.execute_cql("CREATE INDEX idx1 ON tbl (b)").get();
e.execute_cql("CREATE INDEX idx2 ON tbl (c)").get();
e.execute_cql("CREATE MATERIALIZED VIEW tbl_view AS SELECT c FROM tbl WHERE c IS NOT NULL PRIMARY KEY (c, a)").get();
// dropping whole keyspace with MV and SI is fine too
e.execute_cql("DROP KEYSPACE ks").get();
});
});
}
SEASTAR_TEST_CASE(test_insert_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
return e.execute_cql("insert into cf (p1, c1, r1) values ('key1', 1, 100);").discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 100);
}).then([&e] {
return e.execute_cql("update cf set r1 = 66 where p1 = 'key1' and c1 = 1;").discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 66);
});
});
}
SEASTAR_TEST_CASE(test_select_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks_name) {
// CQL: create table cf (p1 varchar, c1 int, c2 int, r1 int, PRIMARY KEY (p1, c1, c2));
return schema({}, ks_name, "cf",
{{"p1", utf8_type}},
{{"c1", int32_type}, {"c2", int32_type}},
{{"r1", int32_type}},
{},
utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, c2, r1) values ('key1', 1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, c2, r1) values ('key2', 1, 2, 13);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, c2, r1) values ('key3', 1, 2, 23);").discard_result();
}).then([&e] {
// Test wildcard
return e.execute_cql("select * from cf where p1 = 'key1' and c2 = 2 and c1 = 1;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)}
});
});
}).then([&e] {
// Test with only regular column
return e.execute_cql("select r1 from cf where p1 = 'key1' and c2 = 2 and c1 = 1;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{int32_type->decompose(3)}
});
});
}).then([&e] {
// Test full partition range, singular clustering range
return e.execute_cql("select * from cf where c1 = 1 and c2 = 2 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(3)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)}})
.with_row({
{utf8_type->decompose(sstring("key2"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(13)}})
.with_row({
{utf8_type->decompose(sstring("key3"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(23)}
});
});
});
});
}
SEASTAR_TEST_CASE(test_cassandra_stress_like_write_and_read) {
return do_with_cql_env([] (cql_test_env& e) {
auto execute_update_for_key = [&e](sstring key) {
return e.execute_cql(sprint("UPDATE cf SET "
"\"C0\" = 0x8f75da6b3dcec90c8a404fb9a5f6b0621e62d39c69ba5758e5f41b78311fbb26cc7a,"
"\"C1\" = 0xa8761a2127160003033a8f4f3d1069b7833ebe24ef56b3beee728c2b686ca516fa51,"
"\"C2\" = 0x583449ce81bfebc2e1a695eb59aad5fcc74d6d7311fc6197b10693e1a161ca2e1c64,"
"\"C3\" = 0x62bcb1dbc0ff953abc703bcb63ea954f437064c0c45366799658bd6b91d0f92908d7,"
"\"C4\" = 0x222fcbe31ffa1e689540e1499b87fa3f9c781065fccd10e4772b4c7039c2efd0fb27 "
"WHERE \"KEY\"=%s;", key)).discard_result();
};
auto verify_row_for_key = [&e](sstring key) {
return e.execute_cql(
sprint("select \"C0\", \"C1\", \"C2\", \"C3\", \"C4\" from cf where \"KEY\" = %s", key)).then(
[](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{from_hex(
"8f75da6b3dcec90c8a404fb9a5f6b0621e62d39c69ba5758e5f41b78311fbb26cc7a")},
{from_hex(
"a8761a2127160003033a8f4f3d1069b7833ebe24ef56b3beee728c2b686ca516fa51")},
{from_hex(
"583449ce81bfebc2e1a695eb59aad5fcc74d6d7311fc6197b10693e1a161ca2e1c64")},
{from_hex(
"62bcb1dbc0ff953abc703bcb63ea954f437064c0c45366799658bd6b91d0f92908d7")},
{from_hex("222fcbe31ffa1e689540e1499b87fa3f9c781065fccd10e4772b4c7039c2efd0fb27")}
});
});
};
return e.create_table([](sstring ks_name) {
return schema({}, ks_name, "cf",
{{"KEY", bytes_type}},
{},
{{"C0", bytes_type},
{"C1", bytes_type},
{"C2", bytes_type},
{"C3", bytes_type},
{"C4", bytes_type}},
{},
utf8_type);
}).then([execute_update_for_key, verify_row_for_key] {
static auto make_key = [](int suffix) { return sprint("0xdeadbeefcafebabe%02d", suffix); };
auto suffixes = boost::irange(0, 10);
return parallel_for_each(suffixes.begin(), suffixes.end(), [execute_update_for_key](int suffix) {
return execute_update_for_key(make_key(suffix));
}).then([suffixes, verify_row_for_key] {
return parallel_for_each(suffixes.begin(), suffixes.end(), [verify_row_for_key](int suffix) {
return verify_row_for_key(make_key(suffix));
});
});
});
});
}
SEASTAR_TEST_CASE(test_range_queries) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks_name) {
return schema({}, ks_name, "cf",
{{"k", bytes_type}},
{{"c0", bytes_type}, {"c1", bytes_type}},
{{"v", bytes_type}},
{},
utf8_type);
}).then([&e] {
return e.execute_cql("update cf set v = 0x01 where k = 0x00 and c0 = 0x01 and c1 = 0x01;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x02 where k = 0x00 and c0 = 0x01 and c1 = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x03 where k = 0x00 and c0 = 0x01 and c1 = 0x03;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x04 where k = 0x00 and c0 = 0x02 and c1 = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x05 where k = 0x00 and c0 = 0x02 and c1 = 0x03;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x06 where k = 0x00 and c0 = 0x02 and c1 = 0x04;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x07 where k = 0x00 and c0 = 0x03 and c1 = 0x04;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x08 where k = 0x00 and c0 = 0x03 and c1 = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({
{from_hex("01")},
{from_hex("02")},
{from_hex("03")},
{from_hex("04")},
{from_hex("05")},
{from_hex("06")},
{from_hex("07")},
{from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 = 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 > 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("07")}, {from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 >= 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}, {from_hex("07")}, {from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 >= 0x02 and c0 < 0x03 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 > 0x02 and c0 <= 0x03 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("07")}, {from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 >= 0x02 and c0 <= 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 < 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")}, {from_hex("02")}, {from_hex("03")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 = 0x02 and c1 > 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 = 0x02 and c1 >= 0x02 and c1 <= 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_ordering_of_composites_with_variable_length_components) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks) {
return schema({}, ks, "cf",
{{"k", bytes_type}},
// We need more than one clustering column so that the single-element tuple format optimisation doesn't kick in
{{"c0", bytes_type}, {"c1", bytes_type}},
{{"v", bytes_type}},
{},
utf8_type);
}).then([&e] {
return e.execute_cql("update cf set v = 0x01 where k = 0x00 and c0 = 0x0001 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x02 where k = 0x00 and c0 = 0x03 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x03 where k = 0x00 and c0 = 0x035555 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x04 where k = 0x00 and c0 = 0x05 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 allow filtering;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")}, {from_hex("02")}, {from_hex("03")}, {from_hex("04")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_query_with_static_columns) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, c blob, v blob, s1 blob static, s2 blob static, primary key (k, c));").discard_result().then([&e] {
return e.execute_cql("update cf set s1 = 0x01 where k = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x02 where k = 0x00 and c = 0x01;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x03 where k = 0x00 and c = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("select s1, v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")},
{from_hex("01"), from_hex("03")},
});
});
}).then([&e] {
return e.execute_cql("select s1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("select s1 from cf limit 1;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("select s1, v from cf limit 1;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")},
});
});
}).then([&e] {
return e.execute_cql("update cf set v = null where k = 0x00 and c = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("select s1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("insert into cf (k, c) values (0x00, 0x02);").discard_result();
}).then([&e] {
return e.execute_cql("select s1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
{from_hex("01")},
});
});
}).then([&e] {
// Try 'in' restriction out
return e.execute_cql("select s1, v from cf where k = 0x00 and c in (0x01, 0x02);").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")},
{from_hex("01"), {}}
});
});
}).then([&e] {
// Verify that limit is respected for multiple clustering ranges and that static columns
// are populated when limit kicks in.
return e.execute_cql("select s1, v from cf where k = 0x00 and c in (0x01, 0x02) limit 1;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_insert_without_clustering_key) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, v blob, primary key (k));").discard_result().then([&e] {
return e.execute_cql("insert into cf (k) values (0x01);").discard_result();
}).then([&e] {
return e.execute_cql("select * from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), {}}
});
});
}).then([&e] {
return e.execute_cql("select k from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_limit_is_respected_across_partitions) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, c blob, v blob, s1 blob static, primary key (k, c));").discard_result().then([&e] {
return e.execute_cql("update cf set s1 = 0x01 where k = 0x01;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set s1 = 0x02 where k = 0x02;").discard_result();
}).then([&e] {
// Determine partition order
return e.execute_cql("select k from cf;");
}).then([&e](shared_ptr<cql_transport::messages::result_message> msg) {
auto rows = dynamic_pointer_cast<cql_transport::messages::result_message::rows>(msg);
BOOST_REQUIRE(rows);
std::vector<bytes> keys;
auto rs = rows->rs().result_set();
for (auto&& row : rs.rows()) {
BOOST_REQUIRE(row[0]);
keys.push_back(*row[0]);
}
BOOST_REQUIRE(keys.size() == 2);
bytes k1 = keys[0];
bytes k2 = keys[1];
return now().then([k1, k2, &e] {
return e.execute_cql("select s1 from cf limit 1;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{k1},
});
});
}).then([&e, k1, k2] {
return e.execute_cql("select s1 from cf limit 2;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{k1}, {k2}
});
});
}).then([&e, k1, k2] {
return e.execute_cql(sprint("update cf set s1 = null where k = 0x%s;", to_hex(k1))).discard_result();
}).then([&e, k1, k2] {
return e.execute_cql("select s1 from cf limit 1;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{k2}
});
});
}).then([&e, k1, k2] {
return e.execute_cql(sprint("update cf set s1 = null where k = 0x%s;", to_hex(k2))).discard_result();
}).then([&e, k1, k2] {
return e.execute_cql("select s1 from cf limit 1;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
});
});
});
}
SEASTAR_TEST_CASE(test_partitions_have_consistent_ordering_in_range_query) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, v int, primary key (k));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (k, v) values (0x01, 0); \n"
" insert into cf (k, v) values (0x02, 0); \n"
" insert into cf (k, v) values (0x03, 0); \n"
" insert into cf (k, v) values (0x04, 0); \n"
" insert into cf (k, v) values (0x05, 0); \n"
" insert into cf (k, v) values (0x06, 0); \n"
"apply batch;"
).discard_result();
}).then([&e] {
// Determine partition order
return e.execute_cql("select k from cf;");
}).then([&e](shared_ptr<cql_transport::messages::result_message> msg) {
auto rows = dynamic_pointer_cast<cql_transport::messages::result_message::rows>(msg);
BOOST_REQUIRE(rows);
std::vector<bytes> keys;
auto rs = rows->rs().result_set();
for (auto&& row : rs.rows()) {
BOOST_REQUIRE(row[0]);
keys.push_back(*row[0]);
}
BOOST_REQUIRE(keys.size() == 6);
return now().then([keys, &e] {
return e.execute_cql("select k from cf limit 1;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 2;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 3;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 4;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 5;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 6;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]},
{keys[5]}
});
});
});
});
});
}
SEASTAR_TEST_CASE(test_partition_range_queries_with_bounds) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, v int, primary key (k));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (k, v) values (0x01, 0); \n"
" insert into cf (k, v) values (0x02, 0); \n"
" insert into cf (k, v) values (0x03, 0); \n"
" insert into cf (k, v) values (0x04, 0); \n"
" insert into cf (k, v) values (0x05, 0); \n"
"apply batch;"
).discard_result();
}).then([&e] {
// Determine partition order
return e.execute_cql("select k, token(k) from cf;");
}).then([&e](shared_ptr<cql_transport::messages::result_message> msg) {
auto rows = dynamic_pointer_cast<cql_transport::messages::result_message::rows>(msg);
BOOST_REQUIRE(rows);
std::vector<bytes> keys;
std::vector<int64_t> tokens;
auto rs = rows->rs().result_set();
for (auto&& row : rs.rows()) {
BOOST_REQUIRE(row[0]);
BOOST_REQUIRE(row[1]);
keys.push_back(*row[0]);
tokens.push_back(value_cast<int64_t>(long_type->deserialize(*row[1])));
}
BOOST_REQUIRE(keys.size() == 5);
return now().then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) > %d;", tokens[1])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[2]},
{keys[3]},
{keys[4]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) >= %ld;", tokens[1])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) > %ld and token(k) < %ld;",
tokens[1], tokens[4])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[2]},
{keys[3]},
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) < %ld;", tokens[3])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) = %ld;", tokens[3])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[3]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) < %ld and token(k) > %ld;", tokens[3], tokens[3])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) >= %ld and token(k) <= %ld;", tokens[4], tokens[2])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([keys, tokens, &e] {
auto min_token = std::numeric_limits<int64_t>::min();
return e.execute_cql(sprint("select k from cf where token(k) > %ld and token (k) < %ld;", min_token, min_token)).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]}
});
});
});
});
});
}
SEASTAR_TEST_CASE(test_deletion_scenarios) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks) {
// CQL: create table cf (k bytes, c bytes, v bytes, primary key (k, c));
return schema({}, ks, "cf",
{{"k", bytes_type}}, {{"c", bytes_type}}, {{"v", bytes_type}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (k, c, v) values (0x00, 0x05, 0x01) using timestamp 1;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("update cf using timestamp 2 set v = null where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{{}},
});
});
}).then([&e] {
// same tampstamp, dead cell wins
return e.execute_cql("update cf using timestamp 2 set v = 0x02 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{{}},
});
});
}).then([&e] {
return e.execute_cql("update cf using timestamp 3 set v = 0x02 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("02")},
});
});
}).then([&e] {
// same timestamp, greater value wins
return e.execute_cql("update cf using timestamp 3 set v = 0x03 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("03")},
});
});
}).then([&e] {
// same tampstamp, delete whole row, delete should win
return e.execute_cql("delete from cf using timestamp 3 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([&e] {
// same timestamp, update should be shadowed by range tombstone
return e.execute_cql("update cf using timestamp 3 set v = 0x04 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([&e] {
return e.execute_cql("update cf using timestamp 4 set v = 0x04 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")},
});
});
}).then([&e] {
// deleting an orphan cell (row is considered as deleted) yields no row
return e.execute_cql("update cf using timestamp 5 set v = null where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
});
});
}
SEASTAR_TEST_CASE(test_range_deletion_scenarios) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("create table cf (p int, c int, v text, primary key (p, c));").get();
for (auto i = 0; i < 10; ++i) {
e.execute_cql(sprint("insert into cf (p, c, v) values (1, %d, 'abc');", i)).get();
}
try {
e.execute_cql("delete from cf where p = 1 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
e.execute_cql("delete from cf where p = 1 and c >= 0 and c <= 3").get();
auto msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_size(6);
e.execute_cql("delete from cf where p = 1 and c > 3 and c < 10").get();
msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_size(0);
e.execute_cql("insert into cf (p, c, v) values (1, 1, '1');").get();
e.execute_cql("insert into cf (p, c, v) values (1, 3, '3');").get();
e.execute_cql("delete from cf where p = 1 and c >= 2 and c <= 3").get();
e.execute_cql("insert into cf (p, c, v) values (1, 2, '2');").get();
msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_size(2);
e.execute_cql("delete from cf where p = 1 and c >= 2 and c <= 3").get();
msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_rows({{ {int32_type->decompose(1)}, {int32_type->decompose(1)}, {utf8_type->decompose("1")} }});
});
}
SEASTAR_TEST_CASE(test_range_deletion_scenarios_with_compact_storage) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("create table cf (p int, c int, v text, primary key (p, c)) with compact storage;").get();
for (auto i = 0; i < 10; ++i) {
e.execute_cql(sprint("insert into cf (p, c, v) values (1, %d, 'abc');", i)).get();
}
try {
e.execute_cql("delete from cf where p = 1 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c > 0 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0 and c < 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c > 0 and c < 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
});
}
SEASTAR_TEST_CASE(test_map_insert_update) {
return do_with_cql_env([] (cql_test_env& e) {
auto make_my_map_type = [] { return map_type_impl::get_instance(int32_type, int32_type, true); };
auto my_map_type = make_my_map_type();
return e.create_table([make_my_map_type] (sstring ks_name) {
// CQL: create table cf (p1 varchar primary key, map1 map<int, int>);
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {}, {{"map1", make_my_map_type()}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, map1) values ('key1', { 1001: 2001 });").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type, map_type_impl::native_type({{1001, 2001}})));
}).then([&e] {
return e.execute_cql("update cf set map1[1002] = 2002 where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1001, 2001},
{1002, 2002}})));
}).then([&e] {
// overwrite an element
return e.execute_cql("update cf set map1[1001] = 3001 where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1001, 3001},
{1002, 2002}})));
}).then([&e] {
// overwrite whole map
return e.execute_cql("update cf set map1 = {1003: 4003} where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1003, 4003}})));
}).then([&e] {
// overwrite whole map, but bad syntax
return e.execute_cql("update cf set map1 = {1003, 4003} where p1 = 'key1';");
}).then_wrapped([](future<shared_ptr<cql_transport::messages::result_message>> f) {
BOOST_REQUIRE(f.failed());
std::move(f).discard_result();
}).then([&e] {
// overwrite whole map
return e.execute_cql(
"update cf set map1 = {1001: 5001, 1002: 5002, 1003: 5003} where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1001, 5001},
{1002, 5002},
{1003, 5003}})));
}).then([&e] {
// discard some keys
return e.execute_cql("update cf set map1 = map1 - {1001, 1003, 1005} where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{{1002, 5002}}})));
}).then([&e, my_map_type] {
return e.execute_cql("select * from cf where p1 = 'key1';").then([my_map_type](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{my_map_type->decompose(make_map_value(my_map_type, map_type_impl::native_type{{{1002, 5002}}}))},
});
});
}).then([&e] {
// overwrite an element
return e.execute_cql("update cf set map1[1009] = 5009 where p1 = 'key1';").discard_result();
}).then([&e] {
// delete a key
return e.execute_cql("delete map1[1002] from cf where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{{1009, 5009}}})));
}).then([&e] {
return e.execute_cql("insert into cf (p1, map1) values ('key1', null);").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type, map_type_impl::native_type({})));
});
});
}
SEASTAR_TEST_CASE(test_set_insert_update) {
return do_with_cql_env([] (cql_test_env& e) {
auto make_my_set_type = [] { return set_type_impl::get_instance(int32_type, true); };
auto my_set_type = make_my_set_type();
return e.create_table([make_my_set_type](sstring ks_name) {
// CQL: create table cf (p1 varchar primary key, set1 set<int>);
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {}, {{"set1", make_my_set_type()}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, set1) values ('key1', { 1001 });").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({{1001}})));
}).then([&e] {
return e.execute_cql("update cf set set1 = set1 + { 1002 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({1001, 1002})));
}).then([&e] {
// overwrite an element
return e.execute_cql("update cf set set1 = set1 + { 1001 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({1001, 1002})));
}).then([&e] {
// overwrite entire set
return e.execute_cql("update cf set set1 = { 1007, 1019 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({1007, 1019})));
}).then([&e] {
// discard keys
return e.execute_cql("update cf set set1 = set1 - { 1007, 1008 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({{1019}})));
}).then([&e, my_set_type] {
return e.execute_cql("select * from cf where p1 = 'key1';").then([my_set_type](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{my_set_type->decompose(make_set_value(my_set_type, set_type_impl::native_type{{1019}}))},
});
});
}).then([&e] {
return e.execute_cql("update cf set set1 = set1 + { 1009 } where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql("delete set1[1019] from cf where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({{1009}})));
}).then([&e] {
return e.execute_cql("insert into cf (p1, set1) values ('key1', null);").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({})));
});
});
}
SEASTAR_TEST_CASE(test_list_insert_update) {
return do_with_cql_env([] (cql_test_env& e) {
auto my_list_type = list_type_impl::get_instance(int32_type, true);
return e.execute_cql("create table cf (p1 varchar primary key, list1 list<int>);").discard_result().then([&e] {
return e.execute_cql("insert into cf (p1, list1) values ('key1', [ 1001 ]);").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({{1001}})));
}).then([&e] {
return e.execute_cql("update cf set list1 = [ 1002, 1003 ] where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({1002, 1003})));
}).then([&e] {
return e.execute_cql("update cf set list1[1] = 2003 where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({1002, 2003})));
}).then([&e] {
return e.execute_cql("update cf set list1 = list1 - [1002, 2004] where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({{2003}})));
}).then([&e, my_list_type] {
return e.execute_cql("select * from cf where p1 = 'key1';").then([my_list_type] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{my_list_type->decompose(make_list_value(my_list_type, list_type_impl::native_type({{2003}})))},
});
});
}).then([&e] {
return e.execute_cql("update cf set list1 = [2008, 2009, 2010] where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql("delete list1[1] from cf where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({2008, 2010})));
}).then([&e] {
return e.execute_cql("update cf set list1 = list1 + [2012, 2019] where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({2008, 2010, 2012, 2019})));
}).then([&e] {
return e.execute_cql("update cf set list1 = [2001, 2002] + list1 where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({2001, 2002, 2008, 2010, 2012, 2019})));
}).then([&e] {
return e.execute_cql("insert into cf (p1, list1) values ('key1', null);").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({})));
});
});
}
SEASTAR_TEST_CASE(test_functions) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks_name) {
// CQL: create table cf (p1 varchar primary key, u uuid, tu timeuuid);
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {{"c1", int32_type}}, {{"tu", timeuuid_type}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, tu) values ('key1', 1, now());").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, tu) values ('key1', 2, now());").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, tu) values ('key1', 3, now());").discard_result();
}).then([&e] {
return e.execute_cql("select tu from cf where p1 in ('key1');");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
using namespace cql_transport::messages;
struct validator : result_message::visitor {
std::vector<bytes_opt> res;
virtual void visit(const result_message::void_message&) override { throw "bad"; }
virtual void visit(const result_message::set_keyspace&) override { throw "bad"; }
virtual void visit(const result_message::prepared::cql&) override { throw "bad"; }
virtual void visit(const result_message::prepared::thrift&) override { throw "bad"; }
virtual void visit(const result_message::schema_change&) override { throw "bad"; }
virtual void visit(const result_message::rows& rows) override {
auto rs = rows.rs().result_set();
BOOST_REQUIRE_EQUAL(rs.rows().size(), 3);
for (auto&& rw : rs.rows()) {
BOOST_REQUIRE_EQUAL(rw.size(), 1);
res.push_back(rw[0]);
}
}
};
validator v;
msg->accept(v);
// No boost::adaptors::sorted
boost::sort(v.res);
BOOST_REQUIRE_EQUAL(boost::distance(v.res | boost::adaptors::uniqued), 3);
}).then([&] {
return e.execute_cql("select sum(c1), count(c1) from cf where p1 = 'key1';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{int32_type->decompose(6)},
{long_type->decompose(3L)},
});
}).then([&] {
return e.execute_cql("select count(*) from cf where p1 = 'key1';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{long_type->decompose(3L)},
});
}).then([&] {
return e.execute_cql("select count(1) from cf where p1 = 'key1';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{long_type->decompose(3L)},
});
}).then([&e] {
// Inane, casting to own type, but couldn't find more interesting example
return e.execute_cql("insert into cf (p1, c1) values ((text)'key2', 7);").discard_result();
}).then([&e] {
return e.execute_cql("select c1 from cf where p1 = 'key2';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{int32_type->decompose(7)},
});
});
});
}
static const api::timestamp_type the_timestamp = 123456789;
SEASTAR_TEST_CASE(test_writetime_and_ttl) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar primary key, i int);").discard_result().then([&e] {
auto q = sprint("insert into cf (p1, i) values ('key1', 1) using timestamp %d;", the_timestamp);
return e.execute_cql(q).discard_result();
}).then([&e] {
return e.execute_cql("select writetime(i) from cf where p1 in ('key1');");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({{
{long_type->decompose(int64_t(the_timestamp))},
}});
});
});
}
SEASTAR_TEST_CASE(test_batch) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (p1, c1, r1) values ('key1', 1, 100); \n"
" insert into cf (p1, c1, r1) values ('key1', 2, 200); \n"
"apply batch;"
).discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 100);
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {2}, "r1", 200);
});
});
}
SEASTAR_TEST_CASE(test_tuples) {
auto make_tt = [] { return tuple_type_impl::get_instance({int32_type, long_type, utf8_type}); };
auto tt = make_tt();
return do_with_cql_env([tt, make_tt] (cql_test_env& e) {
return e.create_table([make_tt] (sstring ks_name) {
// this runs on all cores, so create a local tt for each core:
auto tt = make_tt();
// CQL: "create table cf (id int primary key, t tuple<int, bigint, text>);
return schema({}, ks_name, "cf",
{{"id", int32_type}}, {}, {{"t", tt}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (id, t) values (1, (1001, 2001, 'abc1'));").discard_result();
}).then([&e] {
return e.execute_cql("select t from cf where id = 1;");
}).then([&e, tt] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({{
{tt->decompose(make_tuple_value(tt, tuple_type_impl::native_type({int32_t(1001), int64_t(2001), sstring("abc1")})))},
}});
return e.execute_cql("create table cf2 (p1 int PRIMARY KEY, r1 tuple<int, bigint, text>)").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values (1, (1, 2, 'abc'));").discard_result();
}).then([&e] {
return e.execute_cql("select * from cf2 where p1 = 1;");
}).then([&e, tt] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(int32_t(1)), tt->decompose(make_tuple_value(tt, tuple_type_impl::native_type({int32_t(1), int64_t(2), sstring("abc")}))) }
});
});
});
}
SEASTAR_TEST_CASE(test_user_type) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create type ut1 (my_int int, my_bigint bigint, my_text text);").discard_result().then([&e] {
return e.execute_cql("create table cf (id int primary key, t frozen <ut1>);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (id, t) values (1, (1001, 2001, 'abc1'));").discard_result();
}).then([&e] {
return e.execute_cql("select t.my_int, t.my_bigint, t.my_text from cf where id = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({
{int32_type->decompose(int32_t(1001)), long_type->decompose(int64_t(2001)), utf8_type->decompose(sstring("abc1"))},
});
}).then([&e] {
return e.execute_cql("update cf set t = { my_int: 1002, my_bigint: 2002, my_text: 'abc2' } where id = 1;").discard_result();
}).then([&e] {
return e.execute_cql("select t.my_int, t.my_bigint, t.my_text from cf where id = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({
{int32_type->decompose(int32_t(1002)), long_type->decompose(int64_t(2002)), utf8_type->decompose(sstring("abc2"))},
});
}).then([&e] {
return e.execute_cql("insert into cf (id, t) values (2, (frozen<ut1>)(2001, 3001, 'abc4'));").discard_result();
}).then([&e] {
return e.execute_cql("select t from cf where id = 2;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
auto ut = user_type_impl::get_instance("ks", to_bytes("ut1"),
{to_bytes("my_int"), to_bytes("my_bigint"), to_bytes("my_text")},
{int32_type, long_type, utf8_type});
auto ut_val = make_user_value(ut,
user_type_impl::native_type({int32_t(2001),
int64_t(3001),
sstring("abc4")}));
assert_that(msg).is_rows()
.with_rows({
{ut->decompose(ut_val)},
});
});
});
}
//
// Since durations don't have a well-defined ordering on their semantic value, a number of restrictions exist on their
// use.
//
SEASTAR_TEST_CASE(test_duration_restrictions) {
auto validate_request_failure = [] (cql_test_env& env, const sstring& request, const sstring& expected_message) {
return futurize_apply([&] { return env.execute_cql(request); }).then_wrapped([expected_message] (future<shared_ptr<cql_transport::messages::result_message>> f) {
BOOST_REQUIRE_EXCEPTION(f.get(),
exceptions::invalid_request_exception,
[&expected_message](const exceptions::invalid_request_exception& ire) {
BOOST_REQUIRE_EQUAL(expected_message, ire.what());
return true;
});
});
};
return do_with_cql_env([&] (cql_test_env& env) {
return make_ready_future<>().then([&] {
// Disallow "direct" use of durations in ordered collection types to avoid user confusion when their
// ordering doesn't match expectations.
return make_ready_future<>().then([&] {
return validate_request_failure(
env,
"create type my_type (a set<duration>);",
"Durations are not allowed inside sets: set<duration>");
}).then([&] {
return validate_request_failure(
env,
"create type my_type (a map<duration, int>);",
"Durations are not allowed as map keys: map<duration, int>");
});
}).then([&] {
// Disallow any type referring to a duration from being used in a primary key of a table or a materialized
// view.
return make_ready_future<>().then([&] {
return validate_request_failure(
env,
"create table my_table (direct_key duration PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part direct_key");
}).then([&] {
return validate_request_failure(
env,
"create table my_table (collection_key frozen<list<duration>> PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part collection_key");
}).then([&] {
return env.execute_cql("create type my_type0 (span duration);").discard_result().then([&] {
return validate_request_failure(
env,
"create table my_table (udt_key frozen<my_type0> PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part udt_key");
});
}).then([&] {
return validate_request_failure(
env,
"create table my_table (tuple_key tuple<int, duration, int> PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part tuple_key");
}).then([&] {
return env.execute_cql("create table my_table0 (key int PRIMARY KEY, name text, span duration);")
.discard_result().then([&] {
return validate_request_failure(
env,
"create materialized view my_mv as"
" select * from my_table0 "
" primary key (key, span);",
"Cannot use Duration column 'span' in PRIMARY KEY of materialized view");
});
});
}).then([&] {
// Disallow creating secondary indexes on durations.
return validate_request_failure(
env,
"create index my_index on my_table0 (span);",
"Secondary indexes are not supported on duration columns");
}).then([&] {
// Disallow slice-based restrictions and conditions on durations.
//
// Note that multi-column restrictions are only supported on clustering columns (which cannot be `duration`)
// and that multi-column conditions are not supported in the grammar.
return make_ready_future<>().then([&] {
return validate_request_failure(
env,
"select * from my_table0 where key = 0 and span < 3d;",
"Slice restrictions are not supported on duration columns");
}).then([&] {
return validate_request_failure(
env,
"update my_table0 set name = 'joe' where key = 0 if span >= 5m",
"Slice conditions are not supported on durations");
});
});
});
}
SEASTAR_TEST_CASE(test_select_multiple_ranges) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, r1 int, PRIMARY KEY (p1));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (p1, r1) values ('key1', 100); \n"
" insert into cf (p1, r1) values ('key2', 200); \n"
"apply batch;"
).discard_result();
}).then([&e] {
return e.execute_cql("select r1 from cf where p1 in ('key1', 'key2');");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2).with_row({
{int32_type->decompose(100)}
}).with_row({
{int32_type->decompose(200)}
});
});
});
}
SEASTAR_TEST_CASE(test_validate_keyspace) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql("create keyspace kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkssssssssssssssssssssssssssssssssssssssssssssss with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace ks3-1 with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace ks3 with replication = { 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace ks3 with rreplication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace SyStEm with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
});
});
}
SEASTAR_TEST_CASE(test_validate_table) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql("create table ttttttttttttttttttttttttttttttttttttttttbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb (foo text PRIMARY KEY, bar text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, foo text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb-1 (foo text PRIMARY KEY, bar text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text, bar text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text PRIMARY KEY);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text) with commment = 'aaaa';");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text) with min_index_interval = -1;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text) with min_index_interval = 1024 and max_index_interval = 128;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
});
});
}
SEASTAR_TEST_CASE(test_table_compression) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql("create table tb1 (foo text PRIMARY KEY, bar text) with compression = { };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb1");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb1")->get_compressor_params().get_compressor() == nullptr);
return e.execute_cql("create table tb5 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : '' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb5");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb5")->get_compressor_params().get_compressor() == nullptr);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LossyCompressor' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LZ4Compressor', 'chunk_length_kb' : -1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LZ4Compressor', 'chunk_length_kb' : 3 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LZ4Compressor', 'chunk_length_kb' : 2 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb2");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb2")->get_compressor_params().get_compressor() == compressor::lz4);
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb2")->get_compressor_params().chunk_length() == 2 * 1024);
return e.execute_cql("create table tb3 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'DeflateCompressor' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb3");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb3")->get_compressor_params().get_compressor() == compressor::deflate);
return e.execute_cql("create table tb4 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'org.apache.cassandra.io.compress.DeflateCompressor' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb4");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb4")->get_compressor_params().get_compressor() == compressor::deflate);
});
});
}
SEASTAR_TEST_CASE(test_ttl) {
return do_with_cql_env([] (cql_test_env& e) {
auto make_my_list_type = [] { return list_type_impl::get_instance(utf8_type, true); };
auto my_list_type = make_my_list_type();
return e.create_table([make_my_list_type] (sstring ks_name) {
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {}, {{"r1", utf8_type}, {"r2", utf8_type}, {"r3", make_my_list_type()}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql(
"update cf using ttl 100000 set r1 = 'value1_1', r3 = ['a', 'b', 'c'] where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql(
"update cf using ttl 100 set r1 = 'value1_3', r3 = ['a', 'b', 'c'] where p1 = 'key3';").discard_result();
}).then([&e] {
return e.execute_cql("update cf using ttl 100 set r3[1] = 'b' where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql("update cf using ttl 100 set r1 = 'value1_2' where p1 = 'key2';").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, r2) values ('key2', 'value2_2');").discard_result();
}).then([&e, my_list_type] {
return e.execute_cql("select r1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({utf8_type->decompose(sstring("value1_1"))})
.with_row({utf8_type->decompose(sstring("value1_2"))})
.with_row({utf8_type->decompose(sstring("value1_3"))});
});
}).then([&e, my_list_type] {
return e.execute_cql("select r3 from cf where p1 = 'key1';").then([my_list_type] (shared_ptr<cql_transport::messages::result_message> msg) {
auto my_list_type = list_type_impl::get_instance(utf8_type, true);
assert_that(msg).is_rows().with_rows({
{my_list_type->decompose(make_list_value(my_list_type, list_type_impl::native_type{{sstring("a"), sstring("b"), sstring("c")}}))}
});
});
}).then([&e] {
forward_jump_clocks(200s);
return e.execute_cql("select r1, r2 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2)
.with_row({{}, utf8_type->decompose(sstring("value2_2"))})
.with_row({utf8_type->decompose(sstring("value1_1")), {}});
});
}).then([&e] {
return e.execute_cql("select r2 from cf;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2)
.with_row({ utf8_type->decompose(sstring("value2_2")) })
.with_row({ {} });
});
}).then([&e] {
return e.execute_cql("select r1 from cf;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2)
.with_row({ {} })
.with_row({ utf8_type->decompose(sstring("value1_1")) });
});
}).then([&e, my_list_type] {
return e.execute_cql("select r3 from cf where p1 = 'key1';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
auto my_list_type = list_type_impl::get_instance(utf8_type, true);
assert_that(msg).is_rows().with_rows({
{my_list_type->decompose(make_list_value(my_list_type, list_type_impl::native_type{{sstring("a"), sstring("c")}}))}
});
});
}).then([&e] {
return e.execute_cql("create table cf2 (p1 text PRIMARY KEY, r1 text, r2 text);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values ('foo', 'bar') using ttl 500;").discard_result();
}).then([&e] {
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{utf8_type->decompose(sstring("foo")), utf8_type->decompose(sstring("bar"))}
});
});
}).then([&e] {
forward_jump_clocks(600s);
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
}).then([&e] {
return e.execute_cql("select p1, r1 from cf2;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
}).then([&e] {
return e.execute_cql("select count(*) from cf2;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{long_type->decompose(int64_t(0))}
});
});
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values ('foo', 'bar') using ttl 500;").discard_result();
}).then([&e] {
return e.execute_cql("update cf2 set r1 = null where p1 = 'foo';").discard_result();
}).then([&e] {
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{utf8_type->decompose(sstring("foo")), { }}
});
});
}).then([&e] {
forward_jump_clocks(600s);
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values ('foo', 'bar') using ttl 500;").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r2) values ('foo', null);").discard_result();
}).then([&e] {
forward_jump_clocks(600s);
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{utf8_type->decompose(sstring("foo")), { }}
});
});
});
});
}
SEASTAR_TEST_CASE(test_types) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql(
"CREATE TABLE all_types ("
" a ascii PRIMARY KEY,"
" b bigint,"
" c blob,"
" d boolean,"
" e double,"
" f float,"
" g inet,"
" h int,"
" i text,"
" j timestamp,"
" k timeuuid,"
" l uuid,"
" m varchar,"
" n varint,"
" o decimal,"
" p tinyint,"
" q smallint,"
" r date,"
" s time,"
" u duration,"
");").discard_result();
}).then([&e] {
e.require_table_exists("ks", "all_types");
return e.execute_cql(
"INSERT INTO all_types (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, u) VALUES ("
" 'ascii',"
" 123456789,"
" 0xdeadbeef,"
" true,"
" 3.14,"
" 3.14,"
" '127.0.0.1',"
" 3,"
" 'zażółć gęślą jaźń',"
" '2001-10-18 14:15:55.134+0000',"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" 'varchar',"
" 123,"
" 1.23,"
" 3,"
" 3,"
" '1970-01-02',"
" '00:00:00.000000001',"
" 1y2mo3w4d5h6m7s8ms9us10ns"
");").discard_result();
}).then([&e] {
return e.execute_cql("SELECT * FROM all_types WHERE a = 'ascii'");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
struct tm t = { 0 };
t.tm_year = 2001 - 1900;
t.tm_mon = 10 - 1;
t.tm_mday = 18;
t.tm_hour = 14;
t.tm_min = 15;
t.tm_sec = 55;
auto tp = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(134);
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii")), long_type->decompose(123456789l),
from_hex("deadbeef"), boolean_type->decompose(true),
double_type->decompose(3.14), float_type->decompose(3.14f),
inet_addr_type->decompose(net::inet_address("127.0.0.1")),
int32_type->decompose(3), utf8_type->decompose(sstring("zażółć gęślą jaźń")),
timestamp_type->decompose(tp),
timeuuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
uuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
utf8_type->decompose(sstring("varchar")), varint_type->decompose(boost::multiprecision::cpp_int(123)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(123) }),
byte_type->decompose(int8_t(3)),
short_type->decompose(int16_t(3)),
simple_date_type->decompose(int32_t(0x80000001)),
time_type->decompose(int64_t(0x0000000000000001)),
duration_type->decompose(cql_duration("1y2mo3w4d5h6m7s8ms9us10ns"))
}
});
return e.execute_cql(
"INSERT INTO all_types (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, u) VALUES ("
" blobAsAscii(asciiAsBlob('ascii2')),"
" blobAsBigint(bigintAsBlob(123456789)),"
" bigintAsBlob(12),"
" blobAsBoolean(booleanAsBlob(true)),"
" blobAsDouble(doubleAsBlob(3.14)),"
" blobAsFloat(floatAsBlob(3.14)),"
" blobAsInet(inetAsBlob('127.0.0.1')),"
" blobAsInt(intAsBlob(3)),"
" blobAsText(textAsBlob('zażółć gęślą jaźń')),"
" blobAsTimestamp(timestampAsBlob('2001-10-18 14:15:55.134+0000')),"
" blobAsTimeuuid(timeuuidAsBlob(d2177dd0-eaa2-11de-a572-001b779c76e3)),"
" blobAsUuid(uuidAsBlob(d2177dd0-eaa2-11de-a572-001b779c76e3)),"
" blobAsVarchar(varcharAsBlob('varchar')), blobAsVarint(varintAsBlob(123)),"
" blobAsDecimal(decimalAsBlob(1.23)),"
" blobAsTinyint(tinyintAsBlob(3)),"
" blobAsSmallint(smallintAsBlob(3)),"
" blobAsDate(dateAsBlob('1970-01-02')),"
" blobAsTime(timeAsBlob('00:00:00.000000001')),"
" blobAsDuration(durationAsBlob(10y9mo8w7d6h5m4s3ms2us1ns))"
");").discard_result();
}).then([&e] {
return e.execute_cql("SELECT * FROM all_types WHERE a = 'ascii2'");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
struct tm t = {0};
t.tm_year = 2001 - 1900;
t.tm_mon = 10 - 1;
t.tm_mday = 18;
t.tm_hour = 14;
t.tm_min = 15;
t.tm_sec = 55;
auto tp = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(134);
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii2")), long_type->decompose(123456789l),
from_hex("000000000000000c"), boolean_type->decompose(true),
double_type->decompose(3.14), float_type->decompose(3.14f),
inet_addr_type->decompose(net::inet_address("127.0.0.1")),
int32_type->decompose(3), utf8_type->decompose(sstring("zażółć gęślą jaźń")),
timestamp_type->decompose(tp),
timeuuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
uuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
utf8_type->decompose(sstring("varchar")), varint_type->decompose(boost::multiprecision::cpp_int(123)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(123) }),
byte_type->decompose(int8_t(3)),
short_type->decompose(int16_t(3)),
simple_date_type->decompose(int32_t(0x80000001)),
time_type->decompose(int64_t(0x0000000000000001)),
duration_type->decompose(cql_duration("10y9mo8w7d6h5m4s3ms2us1ns"))
}
});
});
});
}
SEASTAR_TEST_CASE(test_order_by) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table torder (p1 int, c1 int, c2 int, r1 int, r2 int, PRIMARY KEY(p1, c1, c2));").discard_result().then([&e] {
e.require_table_exists("ks", "torder");
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 2, 1, 0);").discard_result();
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
});
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 1, 1, 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 2, 2, 5);").discard_result();
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
});
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (1, 1, 0, 6);").discard_result();
}).then([&e] {
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (1, 2, 3, 7);").discard_result();
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(7)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
{int32_type->decompose(1), int32_type->decompose(0), int32_type->decompose(6)},
});
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 asc, c2 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(0), int32_type->decompose(6)},
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(7)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) and c1 < 2 order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) and c1 >= 2 order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(7)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(0), int32_type->decompose(6)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 > 1 order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 > 1 order by c1 asc, c2 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 asc, c2 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
});
});
});
}
SEASTAR_TEST_CASE(test_order_by_validate) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table torderv (p1 int, c1 int, c2 int, r1 int, r2 int, PRIMARY KEY(p1, c1, c2));").discard_result().then([&e] {
return e.execute_cql("select c2, r1 from torderv where p1 = 0 order by c desc;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("select c2, r1 from torderv where p1 = 0 order by c2 desc;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("select c2, r1 from torderv where p1 = 0 order by c1 desc, c2 asc;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("select c2, r1 from torderv order by c1 asc;");
}).then_wrapped([] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
});
});
}
SEASTAR_TEST_CASE(test_multi_column_restrictions) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tmcr (p1 int, c1 int, c2 int, c3 int, r1 int, PRIMARY KEY (p1, c1, c2, c3));").discard_result().then([&e] {
e.require_table_exists("ks", "tmcr");
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 0, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 1, 0, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 1, 1, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 0, 0, 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 0, 1, 5);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 1, 0, 6);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 1, 1, 7);").discard_result();
}).then([&e] {
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) = (0, 1, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2) = (0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) in ((0, 1, 0), (1, 0, 1), (0, 1, 0));");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(5)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2) in ((0, 1), (1, 0), (0, 1));");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(3)},
{int32_type->decompose(4)},
{int32_type->decompose(5)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) >= (1, 0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(5)},
{int32_type->decompose(6)},
{int32_type->decompose(7)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) >= (0, 1, 1) and (c1, c2, c3) < (1, 1, 0);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
{int32_type->decompose(4)},
{int32_type->decompose(5)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2) >= (0, 1) and (c1, c2, c3) < (1, 0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(3)},
{int32_type->decompose(4)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) > (0, 1, 0) and (c1, c2) <= (0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
});
});
});
}
SEASTAR_TEST_CASE(test_select_distinct) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tsd (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
e.require_table_exists("ks", "tsd");
return e.execute_cql("insert into tsd (p1, c1, r1) values (0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (1, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (1, 1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (2, 2, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (2, 3, 3);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1 from tsd;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0)})
.with_row({int32_type->decompose(1)})
.with_row({int32_type->decompose(2)});
return e.execute_cql("select distinct p1 from tsd limit 3;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0)})
.with_row({int32_type->decompose(1)})
.with_row({int32_type->decompose(2)});
return e.execute_cql("create table tsd2 (p1 int, p2 int, c1 int, r1 int, PRIMARY KEY ((p1, p2), c1));").discard_result();
}).then([&e] {
e.require_table_exists("ks", "tsd2");
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (0, 0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (0, 0, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (1, 1, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (1, 1, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (2, 2, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (2, 2, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1, p2 from tsd2;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0), int32_type->decompose(0)})
.with_row({int32_type->decompose(1), int32_type->decompose(1)})
.with_row({int32_type->decompose(2), int32_type->decompose(2)});
return e.execute_cql("select distinct p1, p2 from tsd2 limit 3;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0), int32_type->decompose(0)})
.with_row({int32_type->decompose(1), int32_type->decompose(1)})
.with_row({int32_type->decompose(2), int32_type->decompose(2)});
return e.execute_cql("create table tsd3 (p1 int, r1 int, PRIMARY KEY (p1));").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (2, 2);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1 from tsd3;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0)})
.with_row({int32_type->decompose(1)})
.with_row({int32_type->decompose(2)});
return e.execute_cql("create table tsd4 (p1 int, c1 int, s1 int static, r1 int, PRIMARY KEY (p1, c1));").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, c1, s1, r1) values (0, 0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, c1, r1) values (0, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, s1) values (2, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, s1) values (3, 2);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1, s1 from tsd4;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0), int32_type->decompose(0)})
.with_row({int32_type->decompose(2), int32_type->decompose(1)})
.with_row({int32_type->decompose(3), int32_type->decompose(2)});
});
});
}
SEASTAR_TEST_CASE(test_select_distinct_with_where_clause) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE cf (k int, a int, b int, PRIMARY KEY (k, a))").get();
for (int i = 0; i < 10; i++) {
e.execute_cql(sprint("INSERT INTO cf (k, a, b) VALUES (%d, %d, %d)", i, i, i)).get();
e.execute_cql(sprint("INSERT INTO cf (k, a, b) VALUES (%d, %d, %d)", i, i * 10, i * 10)).get();
}
BOOST_REQUIRE_THROW(e.execute_cql("SELECT DISTINCT k FROM cf WHERE a >= 80 ALLOW FILTERING").get(), std::exception);
BOOST_REQUIRE_THROW(e.execute_cql("SELECT DISTINCT k FROM cf WHERE k IN (1, 2, 3) AND a = 10").get(), std::exception);
BOOST_REQUIRE_THROW(e.execute_cql("SELECT DISTINCT k FROM cf WHERE b = 5").get(), std::exception);
assert_that(e.execute_cql("SELECT DISTINCT k FROM cf WHERE k = 1").get0())
.is_rows().with_size(1)
.with_row({int32_type->decompose(1)});
assert_that(e.execute_cql("SELECT DISTINCT k FROM cf WHERE k IN (5, 6, 7)").get0())
.is_rows().with_size(3)
.with_row({int32_type->decompose(5)})
.with_row({int32_type->decompose(6)})
.with_row({int32_type->decompose(7)});
// static columns
e.execute_cql("CREATE TABLE cf2 (k int, a int, s int static, b int, PRIMARY KEY (k, a))").get();
for (int i = 0; i < 10; i++) {
e.execute_cql(sprint("INSERT INTO cf2 (k, a, b, s) VALUES (%d, %d, %d, %d)", i, i, i, i)).get();
e.execute_cql(sprint("INSERT INTO cf2 (k, a, b, s) VALUES (%d, %d, %d, %d)", i, i * 10, i * 10, i * 10)).get();
}
assert_that(e.execute_cql("SELECT DISTINCT s FROM cf2 WHERE k = 5").get0())
.is_rows().with_size(1)
.with_row({int32_type->decompose(50)});
assert_that(e.execute_cql("SELECT DISTINCT s FROM cf2 WHERE k IN (5, 6, 7)").get0())
.is_rows().with_size(3)
.with_row({int32_type->decompose(50)})
.with_row({int32_type->decompose(60)})
.with_row({int32_type->decompose(70)});
});
});
}
SEASTAR_TEST_CASE(test_batch_insert_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
return e.execute_cql(R"(BEGIN BATCH
insert into cf (p1, c1, r1) values ('key1', 1, 100);
insert into cf (p1, c1, r1) values ('key2', 2, 200);
APPLY BATCH;)"
).discard_result();
}).then([&e] {
return e.execute_cql(R"(BEGIN BATCH
update cf set r1 = 66 where p1 = 'key1' and c1 = 1;
update cf set r1 = 33 where p1 = 'key2' and c1 = 2;
APPLY BATCH;)"
).discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 66);
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key2")}, {2}, "r1", 33);
});
});
}
SEASTAR_TEST_CASE(test_in_restriction) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tir (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
e.require_table_exists("ks", "tir");
return e.execute_cql("insert into tir (p1, c1, r1) values (0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (1, 0, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (1, 1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (2, 3, 4);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tir where p1 in ();");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(0);
return e.execute_cql("select r1 from tir where p1 in (2, 0, 2, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows_ignore_order({
{int32_type->decompose(4)},
{int32_type->decompose(0)},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tir where p1 = 1 and c1 in ();");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(0);
return e.execute_cql("select r1 from tir where p1 = 1 and c1 in (2, 0, 2, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tir where p1 = 1 and c1 in (2, 0, 2, 1) order by c1 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
{int32_type->decompose(2)},
{int32_type->decompose(1)},
});
return e.prepare("select r1 from tir where p1 in ?");
}).then([&e] (cql3::prepared_cache_key_type prepared_id){
auto my_list_type = list_type_impl::get_instance(int32_type, true);
std::vector<cql3::raw_value> raw_values;
auto in_values_list = my_list_type->decompose(make_list_value(my_list_type,
list_type_impl::native_type{{int(2), int(0), int(2), int(1)}}));
raw_values.emplace_back(cql3::raw_value::make_value(in_values_list));
return e.execute_prepared(prepared_id,raw_values);
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows_ignore_order({
{int32_type->decompose(4)},
{int32_type->decompose(0)},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
}).then([&e]{
return e.execute_cql("create table tir2 (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1,r1));").discard_result();
}).then([&e] {
e.require_table_exists("ks", "tir2");
return e.execute_cql("insert into tir2 (p1, c1, r1) values (0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (1, 0, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (1, 1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (2, 3, 4);").discard_result();
}).then([&e]{
return e.execute_cql("select r1 from tir2 where (c1,r1) in ((0, 1),(1,2),(0,1),(1,2),(3,3));");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows_ignore_order({
{int32_type->decompose(1)},
{int32_type->decompose(2)},
});
});
});
}
SEASTAR_TEST_CASE(test_compact_storage) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tcs (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1)) with compact storage;").discard_result().then([&e] {
return e.require_table_exists("ks", "tcs");
}).then([&e] {
return e.execute_cql("insert into tcs (p1, c1, r1) values (1, 2, 3);").discard_result();
}).then([&e] {
return e.require_column_has_value("tcs", {1}, {2}, "r1", 3);
}).then([&e] {
return e.execute_cql("update tcs set r1 = 4 where p1 = 1 and c1 = 2;").discard_result();
}).then([&e] {
return e.require_column_has_value("tcs", {1}, {2}, "r1", 4);
}).then([&e] {
return e.execute_cql("select * from tcs where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(4) },
});
return e.execute_cql("create table tcs2 (p1 int, c1 int, PRIMARY KEY (p1, c1)) with compact storage;").discard_result();
}).then([&e] {
return e.require_table_exists("ks", "tcs2");
}).then([&e] {
return e.execute_cql("insert into tcs2 (p1, c1) values (1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs2 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2) },
});
return e.execute_cql("create table tcs3 (p1 int, c1 int, c2 int, r1 int, PRIMARY KEY (p1, c1, c2)) with compact storage;").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, c2, r1) values (1, 2, 3, 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, r1) values (1, 2, 5);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, r1) values (1, 3, 6);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, c2, r1) values (1, 3, 5, 7);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, c2, r1) values (1, 3, blobasint(0x), 8);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), {}, int32_type->decompose(5) },
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4) },
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
{ int32_type->decompose(1), int32_type->decompose(3), bytes(), int32_type->decompose(8) },
{ int32_type->decompose(1), int32_type->decompose(3), int32_type->decompose(5), int32_type->decompose(7) },
});
return e.execute_cql("delete from tcs3 where p1 = 1 and c1 = 2;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
{ int32_type->decompose(1), int32_type->decompose(3), bytes(), int32_type->decompose(8) },
{ int32_type->decompose(1), int32_type->decompose(3), int32_type->decompose(5), int32_type->decompose(7) },
});
return e.execute_cql("delete from tcs3 where p1 = 1 and c1 = 3 and c2 = 5;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
{ int32_type->decompose(1), int32_type->decompose(3), bytes(), int32_type->decompose(8) },
});
return e.execute_cql("delete from tcs3 where p1 = 1 and c1 = 3 and c2 = blobasint(0x);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
});
return e.execute_cql("create table tcs4 (p1 int PRIMARY KEY, c1 int, c2 int) with compact storage;").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs4 (p1) values (1);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs4;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
});
}
SEASTAR_TEST_CASE(test_collections_of_collections) {
return do_with_cql_env([] (cql_test_env& e) {
auto set_of_ints = set_type_impl::get_instance(int32_type, true);
auto set_of_sets = set_type_impl::get_instance(set_of_ints, true);
auto map_of_sets = map_type_impl::get_instance(set_of_ints, int32_type, true);
return e.execute_cql("create table cf_sos (p1 int PRIMARY KEY, v set<frozen<set<int>>>);").discard_result().then([&e] {
return e.execute_cql("insert into cf_sos (p1, v) values (1, {{1, 2}, {3, 4}, {5, 6}});").discard_result();
}).then([&e, set_of_sets, set_of_ints] {
return e.require_column_has_value("cf_sos", {1}, {},
"v", make_set_value(set_of_sets, set_type_impl::native_type({
make_set_value(set_of_ints, set_type_impl::native_type({1, 2})),
make_set_value(set_of_ints, set_type_impl::native_type({3, 4})),
make_set_value(set_of_ints, set_type_impl::native_type({5, 6})),
})));
}).then([&e, set_of_sets, set_of_ints] {
return e.execute_cql("delete v[{3, 4}] from cf_sos where p1 = 1;").discard_result();
}).then([&e, set_of_sets, set_of_ints] {
return e.require_column_has_value("cf_sos", {1}, {},
"v", make_set_value(set_of_sets, set_type_impl::native_type({
make_set_value(set_of_ints, set_type_impl::native_type({1, 2})),
make_set_value(set_of_ints, set_type_impl::native_type({5, 6})),
})));
}).then([&e, set_of_sets, set_of_ints] {
return e.execute_cql("update cf_sos set v = v - {{1, 2}, {5}} where p1 = 1;").discard_result();
}).then([&e, set_of_sets, set_of_ints] {
return e.require_column_has_value("cf_sos", {1}, {},
"v", make_set_value(set_of_sets, set_type_impl::native_type({
make_set_value(set_of_ints, set_type_impl::native_type({5, 6})),
})));
}).then([&e] {
return e.execute_cql("create table cf_mos (p1 int PRIMARY KEY, v map<frozen<set<int>>, int>);").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.execute_cql("insert into cf_mos (p1, v) values (1, {{1, 2}: 7, {3, 4}: 8, {5, 6}: 9});").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.require_column_has_value("cf_mos", {1}, {},
"v", make_map_value(map_of_sets, map_type_impl::native_type({
{ make_set_value(set_of_ints, set_type_impl::native_type({1, 2})), 7 },
{ make_set_value(set_of_ints, set_type_impl::native_type({3, 4})), 8 },
{ make_set_value(set_of_ints, set_type_impl::native_type({5, 6})), 9 },
})));
}).then([&e, map_of_sets, set_of_ints] {
return e.execute_cql("delete v[{3, 4}] from cf_mos where p1 = 1;").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.require_column_has_value("cf_mos", {1}, {},
"v", make_map_value(map_of_sets, map_type_impl::native_type({
{ make_set_value(set_of_ints, set_type_impl::native_type({1, 2})), 7 },
{ make_set_value(set_of_ints, set_type_impl::native_type({5, 6})), 9 },
})));
}).then([&e, map_of_sets, set_of_ints] {
return e.execute_cql("update cf_mos set v = v - {{1, 2}, {5}} where p1 = 1;").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.require_column_has_value("cf_mos", {1}, {},
"v", make_map_value(map_of_sets, map_type_impl::native_type({
{ make_set_value(set_of_ints, set_type_impl::native_type({5, 6})), 9 },
})));
});
});
}
SEASTAR_TEST_CASE(test_result_order) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tro (p1 int, c1 text, r1 int, PRIMARY KEY (p1, c1)) with compact storage;").discard_result().then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'z', 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'bbbb', 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'a', 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'aaa', 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'bb', 5);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'cccc', 6);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tro where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), utf8_type->decompose(sstring("a")), int32_type->decompose(3) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("aaa")), int32_type->decompose(4) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("bb")), int32_type->decompose(5) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("bbbb")), int32_type->decompose(2) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("cccc")), int32_type->decompose(6) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("z")), int32_type->decompose(1) },
});
});
});
}
SEASTAR_TEST_CASE(test_frozen_collections) {
return do_with_cql_env([] (cql_test_env& e) {
auto set_of_ints = set_type_impl::get_instance(int32_type, false);
auto list_of_ints = list_type_impl::get_instance(int32_type, false);
auto frozen_map_of_set_and_list = map_type_impl::get_instance(set_of_ints, list_of_ints, false);
return e.execute_cql("CREATE TABLE tfc (a int, b int, c frozen<map<set<int>, list<int>>> static, d int, PRIMARY KEY (a, b));").discard_result().then([&e] {
return e.execute_cql("INSERT INTO tfc (a, b, c, d) VALUES (0, 0, {}, 0);").discard_result();
}).then([&e] {
return e.execute_cql("SELECT * FROM tfc;");
}).then([&e, frozen_map_of_set_and_list] (shared_ptr<cql_transport::messages::result_message> msg) {
map_type_impl::mutation_view empty_mv{};
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(0), int32_type->decompose(0), frozen_map_of_set_and_list->to_value(empty_mv, cql_serialization_format::internal()), int32_type->decompose(0) },
});
});
});
}
SEASTAR_TEST_CASE(test_alter_table) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tat (pk1 int, c1 int, ck2 int, r1 int, r2 int, PRIMARY KEY (pk1, c1, ck2));").discard_result().then([&e] {
return e.execute_cql("insert into tat (pk1, c1, ck2, r1, r2) values (1, 2, 3, 4, 5);").discard_result();
}).then([&e] {
return e.execute_cql("alter table tat with comment = 'This is a comment.';").discard_result();
}).then([&e] {
BOOST_REQUIRE_EQUAL(e.local_db().find_schema("ks", "tat")->comment(), sstring("This is a comment."));
return e.execute_cql("alter table tat alter r2 type blob;").discard_result();
}).then([&e] {
return e.execute_cql("select pk1, c1, ck2, r1, r2 from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), int32_type->decompose(5) },
});
}).then([&e] {
return e.execute_cql("insert into tat (pk1, c1, ck2, r2) values (1, 2, 3, 0x1234567812345678);").discard_result();
}).then([&e] {
return e.execute_cql("select pk1, c1, ck2, r1, r2 from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), from_hex("1234567812345678") },
});
}).then([&e] {
return e.execute_cql("alter table tat rename pk1 to p1 and ck2 to c2;").discard_result();
}).then([&e] {
return e.execute_cql("select p1, c1, c2, r1, r2 from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat add r1_2 int;").discard_result();
}).then([&e] {
return e.execute_cql("insert into tat (p1, c1, c2, r1_2) values (1, 2, 3, 6);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), int32_type->decompose(6), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat drop r1;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(6), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat add r1 int;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), {}, int32_type->decompose(6), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat drop r2;").discard_result();
}).then([&e] {
return e.execute_cql("alter table tat add r2 int;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), {}, int32_type->decompose(6), {} },
});
});
});
}
SEASTAR_TEST_CASE(test_map_query) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE xx (k int PRIMARY KEY, m map<text, int>);").get();
e.execute_cql("insert into xx (k, m) values (0, {'v2': 1});").get();
auto m_type = map_type_impl::get_instance(utf8_type, int32_type, true);
assert_that(e.execute_cql("select m from xx where k = 0;").get0())
.is_rows().with_rows({
{ make_map_value(m_type, map_type_impl::native_type({{sstring("v2"), 1}})).serialize() }
});
e.execute_cql("delete m['v2'] from xx where k = 0;").get();
assert_that(e.execute_cql("select m from xx where k = 0;").get0())
.is_rows().with_rows({{{}}});
});
});
}
SEASTAR_TEST_CASE(test_drop_table) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("create table tmp (pk int, v int, PRIMARY KEY (pk));").get();
e.execute_cql("drop columnfamily tmp;").get();
e.execute_cql("create table tmp (pk int, v int, PRIMARY KEY (pk));").get();
e.execute_cql("drop columnfamily tmp;").get();
});
});
}
SEASTAR_TEST_CASE(test_reversed_slice_with_empty_range_before_all_rows) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE test (a int, b int, c int, s1 int static, s2 int static, PRIMARY KEY (a, b));").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 0, 0, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 1, 1, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 2, 2, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 3, 3, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 4, 4, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 5, 5, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 6, 6, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 7, 7, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 8, 8, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 9, 9, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 10, 10, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 11, 11, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 12, 12, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 13, 13, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 14, 14, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 15, 15, 17, 42);").get();
assert_that(e.execute_cql("select * from test WHERE a = 99 and b < 0 ORDER BY b DESC limit 2;").get0())
.is_rows().is_empty();
assert_that(e.execute_cql("select * from test WHERE a = 99 order by b desc;").get0())
.is_rows().with_size(16);
assert_that(e.execute_cql("select * from test;").get0())
.is_rows().with_size(16);
});
});
}
SEASTAR_TEST_CASE(test_query_with_range_tombstones) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE test (pk int, ck int, v int, PRIMARY KEY (pk, ck));").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 0, 0);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 2, 2);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 4, 4);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 5, 5);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 6, 6);").get();
e.execute_cql("DELETE FROM test WHERE pk = 0 AND ck >= 1 AND ck <= 3;").get();
e.execute_cql("DELETE FROM test WHERE pk = 0 AND ck > 4 AND ck <= 8;").get();
e.execute_cql("DELETE FROM test WHERE pk = 0 AND ck > 0 AND ck <= 1;").get();
assert_that(e.execute_cql("SELECT v FROM test WHERE pk = 0 ORDER BY ck DESC;").get0())
.is_rows()
.with_rows({
{ int32_type->decompose(4) },
{ int32_type->decompose(0) },
});
assert_that(e.execute_cql("SELECT v FROM test WHERE pk = 0;").get0())
.is_rows()
.with_rows({
{ int32_type->decompose(0) },
{ int32_type->decompose(4) },
});
});
});
}
SEASTAR_TEST_CASE(test_alter_table_validation) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tatv (p1 int, c1 int, c2 int, r1 int, r2 set<int>, PRIMARY KEY (p1, c1, c2));").discard_result().then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv drop r2;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r2 list<int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r2 set<text>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r2 set<int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv rename r2 to r3;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv alter r1 type bigint;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv alter r2 type map<int, int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r3 map<int, int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r4 set<text>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv drop r3;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv drop r4;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r3 map<int, text>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r4 set<int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r3 map<int, blob>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r4 set<blob>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
});
});
}
SEASTAR_TEST_CASE(test_pg_style_string_literal) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table test (p1 text, PRIMARY KEY (p1));").discard_result().then([&e] {
return e.execute_cql("insert into test (p1) values ($$Apostrophe's$ $ not$ $ '' escaped$$);").discard_result();
}).then([&e] {
return e.execute_cql("insert into test (p1) values ($$$''valid$_$key$$);").discard_result();
}).then([&e] {
return e.execute_cql("insert into test (p1) values ('$normal$valid$$$$key$');").discard_result();
}).then([&e] {
return e.execute_cql("insert into test (p1) values ($ $invalid$$);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("insert into test (p1) values ($$invalid$ $);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("insert into test (p1) values ($ $invalid$$$);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("insert into test (p1) values ($$ \n\n$invalid);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("select * from test;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ utf8_type->decompose(sstring("Apostrophe's$ $ not$ $ '' escaped")) },
{ utf8_type->decompose(sstring("$''valid$_$key")) },
{ utf8_type->decompose(sstring("$normal$valid$$$$key$")) },
});
});
});
}
SEASTAR_TEST_CASE(test_insert_large_collection_values) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
auto map_type = map_type_impl::get_instance(utf8_type, utf8_type, true);
auto set_type = set_type_impl::get_instance(utf8_type, true);
auto list_type = list_type_impl::get_instance(utf8_type, true);
e.create_table([map_type, set_type, list_type] (sstring ks_name) {
// CQL: CREATE TABLE tbl (pk text PRIMARY KEY, m map<text, text>, s set<text>, l list<text>);
return schema({}, ks_name, "tbl",
{{"pk", utf8_type}},
{},
{
{"m", map_type},
{"s", set_type},
{"l", list_type}
},
{},
utf8_type);
}).get();
sstring long_value(std::numeric_limits<uint16_t>::max() + 10, 'x');
e.execute_cql(sprint("INSERT INTO tbl (pk, l) VALUES ('Zamyatin', ['%s']);", long_value)).get();
assert_that(e.execute_cql("SELECT l FROM tbl WHERE pk ='Zamyatin';").get0())
.is_rows().with_rows({
{ make_list_value(list_type, list_type_impl::native_type({{long_value}})).serialize() }
});
BOOST_REQUIRE_THROW(e.execute_cql(sprint("INSERT INTO tbl (pk, s) VALUES ('Orwell', {'%s'});", long_value)).get(), std::exception);
e.execute_cql(sprint("INSERT INTO tbl (pk, m) VALUES ('Haksli', {'key': '%s'});", long_value)).get();
assert_that(e.execute_cql("SELECT m FROM tbl WHERE pk ='Haksli';").get0())
.is_rows().with_rows({
{ make_map_value(map_type, map_type_impl::native_type({{sstring("key"), long_value}})).serialize() }
});
BOOST_REQUIRE_THROW(e.execute_cql(sprint("INSERT INTO tbl (pk, m) VALUES ('Golding', {'%s': 'value'});", long_value)).get(), std::exception);
auto make_query_options = [] (cql_protocol_version_type version) {
return std::make_unique<cql3::query_options>(db::consistency_level::ONE, infinite_timeout_config, std::experimental::nullopt,
std::vector<cql3::raw_value_view>(), false,
cql3::query_options::specific_options::DEFAULT, cql_serialization_format{version});
};
BOOST_REQUIRE_THROW(e.execute_cql("SELECT l FROM tbl WHERE pk = 'Zamyatin';", make_query_options(2)).get(), std::exception);
BOOST_REQUIRE_THROW(e.execute_cql("SELECT m FROM tbl WHERE pk = 'Haksli';", make_query_options(2)).get(), std::exception);
});
});
}
SEASTAR_TEST_CASE(test_select_json_types) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE all_types ("
" a ascii PRIMARY KEY,"
" b bigint,"
" c blob,"
" d boolean,"
" e double,"
" f float,"
" \"G\" inet," // note - case-sensitive column names
" \"H\" int,"
" \"I\" text,"
" j timestamp,"
" k timeuuid,"
" l uuid,"
" m varchar,"
" n varint,"
" o decimal,"
" p tinyint,"
" q smallint,"
" r date,"
" s time,"
" u duration,"
" w int,"
");").get();
e.require_table_exists("ks", "all_types").get();
e.execute_cql(
"INSERT INTO all_types (a, b, c, d, e, f, \"G\", \"H\", \"I\", j, k, l, m, n, o, p, q, r, s, u) VALUES ("
" 'ascii',"
" 123456789,"
" 0xdeadbeef,"
" true,"
" 3.14,"
" 3.14,"
" '127.0.0.1',"
" 3,"
" 'zażółć gęślą jaźń',"
" '2001-10-18 14:15:55.134+0000',"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" 'varchar',"
" 123,"
" 1.23,"
" 3,"
" 3,"
" '1970-01-02',"
" '00:00:00.000000001',"
" 1y2mo3w4d5h6m7s8ms9us10ns"
");").get();
auto msg = e.execute_cql("SELECT JSON a, b, c, d, e, f, \"G\", \"H\", \"I\", j, k, l, m, n, o, p, q, r, s, u, w, unixtimestampof(k) FROM all_types WHERE a = 'ascii'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"ascii\", "
"\"b\": 123456789, "
"\"c\": \"0xdeadbeef\", "
"\"d\": true, "
"\"e\": 3.14, "
"\"f\": 3.14, "
"\"\\\"G\\\"\": \"127.0.0.1\", " // note the double quoting on case-sensitive column names
"\"\\\"H\\\"\": 3, "
"\"\\\"I\\\"\": \"zażółć gęślą jaźń\", "
"\"j\": \"2001-10-18T14:15:55.134000\", "
"\"k\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"l\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"m\": \"varchar\", "
"\"n\": 123, "
"\"o\": 1.23, "
"\"p\": 3, "
"\"q\": 3, "
"\"r\": \"1970-01-02\", "
"\"s\": 00:00:00.000000001, "
"\"u\": \"1y2mo25d5h6m7s8ms9us10ns\", "
"\"w\": null, "
"\"unixtimestampof(k)\": 1261009589805}"
)
}
});
msg = e.execute_cql("SELECT toJson(a), toJson(b), toJson(c), toJson(d), toJson(e), toJson(f),"
"toJson(\"G\"), toJson(\"H\"), toJson(\"I\"), toJson(j), toJson(k), toJson(l), toJson(m), toJson(n),"
"toJson(o), toJson(p), toJson(q), toJson(r), toJson(s), toJson(u), toJson(w),"
"toJson(unixtimestampof(k)), toJson(toJson(toJson(p))) FROM all_types WHERE a = 'ascii'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose("\"ascii\""),
utf8_type->decompose("123456789"),
utf8_type->decompose("\"0xdeadbeef\""),
utf8_type->decompose("true"),
utf8_type->decompose("3.14"),
utf8_type->decompose("3.14"),
utf8_type->decompose("\"127.0.0.1\""),
utf8_type->decompose("3"),
utf8_type->decompose("\"zażółć gęślą jaźń\""),
utf8_type->decompose("\"2001-10-18T14:15:55.134000\""),
utf8_type->decompose("\"d2177dd0-eaa2-11de-a572-001b779c76e3\""),
utf8_type->decompose("\"d2177dd0-eaa2-11de-a572-001b779c76e3\""),
utf8_type->decompose("\"varchar\""),
utf8_type->decompose("123"),
utf8_type->decompose("1.23"),
utf8_type->decompose("3"),
utf8_type->decompose("3"),
utf8_type->decompose("\"1970-01-02\""),
utf8_type->decompose("00:00:00.000000001"),
utf8_type->decompose("\"1y2mo25d5h6m7s8ms9us10ns\""),
utf8_type->decompose("null"),
utf8_type->decompose("1261009589805"),
utf8_type->decompose("\"\\\"3\\\"\"")
}
});
});
}
SEASTAR_TEST_CASE(test_select_json_collections) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE collections ("
" a text PRIMARY KEY,"
" b map<int, text>,"
" c set<float>,"
" d list<frozen<list<tinyint>>>"
");").get();
e.require_table_exists("ks", "collections").get();
e.execute_cql(
"INSERT INTO collections (a, b, c, d) VALUES ("
" 'key',"
" { 1 : 'abc', 3 : 'de', 2 : '!' },"
" { 0.0, 4.5, 2.25, 1.125, NAN, INFINITY },"
" [[ 3 , 1, 4, 1, 5, 9 ], [ ], [ 1, 1, 2 ]]"
");").get();
auto msg = e.execute_cql("SELECT JSON * FROM collections WHERE a = 'key'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"key\", "
"\"b\": {\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}, "
"\"c\": [0, 1.125, 2.25, 4.5, null, null], " // note - one null is for NAN, one for INFINITY
"\"d\": [[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]}"
)
}
});
msg = e.execute_cql("SELECT toJson(a), toJson(b), toJson(c), toJson(d) FROM collections WHERE a = 'key'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose("\"key\""),
utf8_type->decompose("{\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}"),
utf8_type->decompose("[0, 1.125, 2.25, 4.5, null, null]"),
utf8_type->decompose("[[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]"),
}
});
try {
e.execute_cql("SELECT toJson(a, b) FROM collections WHERE a = 'key'").get();
BOOST_FAIL("should've thrown");
} catch (...) {}
try {
e.execute_cql("SELECT toJson() FROM collections WHERE a = 'key'").get();
BOOST_FAIL("should've thrown");
} catch (...) {}
});
}
SEASTAR_TEST_CASE(test_insert_json_types) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE all_types ("
" a ascii PRIMARY KEY,"
" b bigint,"
" c blob,"
" d boolean,"
" e double,"
" f float,"
" \"G\" inet,"
" \"H\" int,"
" \"I\" text,"
" j timestamp,"
" k timeuuid,"
" l uuid,"
" m varchar,"
" n varint,"
" o decimal,"
" p tinyint,"
" q smallint,"
" r date,"
" s time,"
" u duration,"
");").get();
e.require_table_exists("ks", "all_types").get();
e.execute_cql(
"INSERT INTO all_types JSON '"
"{\"a\": \"ascii\", "
"\"b\": 123456789, "
"\"c\": \"0xdeadbeef\", "
"\"d\": true, "
"\"e\": 3.14, "
"\"f\": \"3.14\", "
"\"\\\"G\\\"\": \"127.0.0.1\", "
"\"\\\"H\\\"\": 3, "
"\"\\\"I\\\"\": \"zażółć gęślą jaźń\", "
"\"j\": \"2001-10-18T14:15:55.134+0000\", "
"\"k\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"l\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"m\": \"varchar\", "
"\"n\": 123, "
"\"o\": 1.23, "
"\"p\": \"3\", "
"\"q\": 3, "
"\"r\": \"1970-01-02\", "
"\"s\": \"00:00:00.000000001\", "
"\"u\": \"1y2mo25d5h6m7s8ms9us10ns\"}"
"'").get();
auto msg = e.execute_cql("SELECT * FROM all_types WHERE a = 'ascii'").get0();
struct tm t = { 0 };
t.tm_year = 2001 - 1900;
t.tm_mon = 10 - 1;
t.tm_mday = 18;
t.tm_hour = 14;
t.tm_min = 15;
t.tm_sec = 55;
auto tp = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(134);
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii")),
inet_addr_type->decompose(net::inet_address("127.0.0.1")), // note - case-sensitive columns go right after the key
int32_type->decompose(3), utf8_type->decompose(sstring("zażółć gęślą jaźń")),
long_type->decompose(123456789l),
from_hex("deadbeef"), boolean_type->decompose(true),
double_type->decompose(3.14), float_type->decompose(3.14f),
timestamp_type->decompose(tp),
timeuuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
uuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
utf8_type->decompose(sstring("varchar")), varint_type->decompose(boost::multiprecision::cpp_int(123)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(123) }),
byte_type->decompose(int8_t(3)),
short_type->decompose(int16_t(3)),
simple_date_type->decompose(int32_t(0x80000001)),
time_type->decompose(int64_t(0x0000000000000001)),
duration_type->decompose(cql_duration("1y2mo3w4d5h6m7s8ms9us10ns"))
}
});
e.execute_cql("UPDATE all_types SET b = fromJson('42') WHERE a = fromJson('\"ascii\"');").get();
e.execute_cql("UPDATE all_types SET \"I\" = fromJson('\"zażółć gęślą jaźń\"') WHERE a = fromJson('\"ascii\"');").get();
e.execute_cql("UPDATE all_types SET n = fromJson('\"2147483648\"') WHERE a = fromJson('\"ascii\"');").get();
e.execute_cql("UPDATE all_types SET o = fromJson('\"3.45\"') WHERE a = fromJson('\"ascii\"');").get();
msg = e.execute_cql("SELECT a, b, \"I\", n, o FROM all_types WHERE a = 'ascii'").get0();
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii")),
long_type->decompose(42l),
utf8_type->decompose(sstring("zażółć gęślą jaźń")),
varint_type->decompose(boost::multiprecision::cpp_int(2147483648)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(345) }),
}
});
e.execute_cql("CREATE TABLE multi_column_pk_table (p1 int, p2 int, p3 int, c1 int, c2 int, v int, PRIMARY KEY((p1, p2, p3), c1, c2));").get();
e.require_table_exists("ks", "multi_column_pk_table").get();
e.execute_cql("INSERT INTO multi_column_pk_table JSON '"
"{\"p1\": 1, "
"\"p2\": 2, "
"\"p3\": 3, "
"\"c1\": 4, "
"\"c2\": 5, "
"\"v\": 6 "
"}'").get();
msg = e.execute_cql("SELECT * FROM multi_column_pk_table").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5),
int32_type->decompose(6)
}
});
});
}
SEASTAR_TEST_CASE(test_insert_json_collections) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE collections ("
" a text PRIMARY KEY,"
" b map<int, text>,"
" c set<float>,"
" d list<frozen<list<tinyint>>>"
");").get();
e.require_table_exists("ks", "collections").get();
e.execute_cql(
"INSERT INTO collections JSON '"
"{\"a\": \"key\", "
"\"b\": {\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}, "
"\"c\": [0, 1.125, 2.25, 4.5], "
"\"d\": [[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]}"
"'").get();
auto msg = e.execute_cql("SELECT JSON * FROM collections WHERE a = 'key'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"key\", "
"\"b\": {\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}, "
"\"c\": [0, 1.125, 2.25, 4.5], "
"\"d\": [[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]}"
)
}
});
e.execute_cql("INSERT INTO collections JSON '{\"a\": \"key2\"}'").get();
msg = e.execute_cql("SELECT JSON * FROM collections WHERE a = 'key2'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"key2\", "
"\"b\": null, "
"\"c\": null, "
"\"d\": null}"
)
}
});
});
}
SEASTAR_TEST_CASE(test_prepared_json) {
return do_with_cql_env_thread([] (cql_test_env& e) {
auto prepared = e.execute_cql(
"CREATE TABLE json_data ("
" a text PRIMARY KEY,"
" b map<int, text>,"
" c decimal,"
" d list<float>"
");").get();
e.require_table_exists("ks", "json_data").get();
cql3::prepared_cache_key_type prepared_id = e.prepare(
"begin batch \n"
" insert into json_data json :named_bound0; \n"
" insert into json_data json ?; \n"
" insert into json_data json :named_bound1; \n"
" insert into json_data json ?; \n"
"apply batch;").get0();
std::vector<cql3::raw_value> raw_values;
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a1\", \"b\": {\"3\": \"three\", \"6\": \"six\", \"0\": \"zero\"}, \"c\": 1.23, \"d\": [1.25, 3.75, 2.5]}")));
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a2\", \"b\": {\"6\": \"six\", \"0\": \"zero\"}, \"c\": 1.23, \"d\": [3.75, 2.5]}")));
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a3\", \"b\": {\"3\": \"three\", \"0\": \"zero\"}, \"c\": 1.23, \"d\": [1.25, 2.5]}")));
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a4\", \"b\": {\"1\": \"one\"}, \"c\": 1.23, \"d\": [1]}")));
e.execute_prepared(prepared_id, raw_values).get();
auto msg = e.execute_cql("select json * from json_data where a='a1'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a1\", \"b\": {\"0\": \"zero\", \"3\": \"three\", \"6\": \"six\"}, \"c\": 1.23, \"d\": [1.25, 3.75, 2.5]}")
}});
msg = e.execute_cql("select json * from json_data where a='a2'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a2\", \"b\": {\"0\": \"zero\", \"6\": \"six\"}, \"c\": 1.23, \"d\": [3.75, 2.5]}")
}});
msg = e.execute_cql("select json * from json_data where a='a3'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a3\", \"b\": {\"0\": \"zero\", \"3\": \"three\"}, \"c\": 1.23, \"d\": [1.25, 2.5]}")
}});
msg = e.execute_cql("select json * from json_data where a='a4'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a4\", \"b\": {\"1\": \"one\"}, \"c\": 1.23, \"d\": [1]}")
}});
});
}
SEASTAR_TEST_CASE(test_long_text_value) {
return do_with_cql_env_thread([] (cql_test_env& e) {
auto prepared = e.execute_cql("CREATE TABLE t (id int PRIMARY KEY, v text, v2 varchar)").get();
e.require_table_exists("ks", "t").get();
sstring big_one(17324, 'x');
sstring bigger_one(29123, 'y');
e.execute_cql(sprint("INSERT INTO t (id, v, v2) values (1, '%s', '%s')", big_one, big_one)).get();
e.execute_cql(sprint("INSERT INTO t (id, v, v2) values (2, '%s', '%s')", bigger_one, bigger_one)).get();
auto msg = e.execute_cql("select v, v2 from t where id = 1").get0();
assert_that(msg).is_rows().with_rows({{utf8_type->decompose(big_one), utf8_type->decompose(big_one)}});
msg = e.execute_cql("select v, v2 from t where id = 2").get0();
assert_that(msg).is_rows().with_rows({{utf8_type->decompose(bigger_one), utf8_type->decompose(bigger_one)}});
});
}
SEASTAR_TEST_CASE(test_time_conversions) {
return do_with_cql_env_thread([] (cql_test_env& e) {
auto prepared = e.execute_cql(
"CREATE TABLE time_data (id timeuuid PRIMARY KEY, d date, ts timestamp);").get();
e.require_table_exists("ks", "time_data").get();
e.execute_cql("INSERT INTO time_data (id, d, ts) VALUES (f4e30f80-6958-11e8-96d6-000000000000, '2017-06-11', '2018-06-05 00:00:00+0000');").get();
struct tm t = { 0 };
t.tm_year = 2018 - 1900;
t.tm_mon = 6 - 1;
t.tm_mday = 6;
t.tm_hour = 7;
t.tm_min = 12;
t.tm_sec = 22;
auto tp1 = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(136);
t.tm_year = 2017 - 1900;
t.tm_mday = 11;
t.tm_hour = 0;
t.tm_min = 0;
t.tm_sec = 0;
auto tp2 = db_clock::from_time_t(timegm(&t));
auto msg = e.execute_cql("select todate(id), todate(ts), totimestamp(id), totimestamp(d), tounixtimestamp(id),"
"tounixtimestamp(ts), tounixtimestamp(d), tounixtimestamp(totimestamp(todate(totimestamp(todate(id))))) from time_data;").get0();
assert_that(msg).is_rows().with_rows({{
simple_date_type->decompose(int32_t(0x80004518)),
simple_date_type->decompose(int32_t(0x80004517)),
timestamp_type->decompose(tp1),
timestamp_type->decompose(tp2),
long_type->decompose(int64_t(1528269142136)),
long_type->decompose(int64_t(1528156800000)),
long_type->decompose(int64_t(1497139200000)),
long_type->decompose(int64_t(1528243200000))
}});
});
}
// Corner-case test that checks for the paging code's preparedness for an empty
// range list.
SEASTAR_TEST_CASE(test_empty_partition_range_scan) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("create keyspace empty_partition_range_scan with replication = {'class': 'SimpleStrategy', 'replication_factor': 1};").get();
e.execute_cql("create table empty_partition_range_scan.tb (a int, b int, c int, val int, PRIMARY KEY ((a,b),c) );").get();
auto qo = std::make_unique<cql3::query_options>(db::consistency_level::LOCAL_ONE, infinite_timeout_config, std::vector<cql3::raw_value>{},
cql3::query_options::specific_options{1, nullptr, {}, api::new_timestamp()});
auto res = e.execute_cql("select * from empty_partition_range_scan.tb where token (a,b) > 1 and token(a,b) <= 1;", std::move(qo)).get0();
assert_that(res).is_rows().is_empty();
});
}
SEASTAR_TEST_CASE(test_allow_filtering_check) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (p int, c int, v int, PRIMARY KEY(p, c));").get();
e.require_table_exists("ks", "t").get();
for (int i = 0; i < 3; ++i) {
for (int j = 0; j <3; ++j) {
e.execute_cql(sprint("INSERT INTO t(p, c, v) VALUES (%s, %s, %s)", i, j, j)).get();
}
}
std::vector<sstring> queries = {
"SELECT * FROM t WHERE p = 1",
"SELECT * FROM t WHERE p = 1 and c > 2",
"SELECT * FROM t WHERE p = 1 and c = 2"
};
for (const sstring& q : queries) {
e.execute_cql(q).get();
e.execute_cql(q + " ALLOW FILTERING").get();
}
queries = {
"SELECT * FROM t WHERE c = 2",
"SELECT * FROM t WHERE c <= 4"
};
for (const sstring& q : queries) {
BOOST_CHECK_THROW(e.execute_cql(q).get(), exceptions::invalid_request_exception);
e.execute_cql(q + " ALLOW FILTERING").get();
}
e.execute_cql("CREATE TABLE t2 (p int PRIMARY KEY, a int, b int);").get();
e.require_table_exists("ks", "t2").get();
e.execute_cql("CREATE INDEX ON t2(a)").get();
for (int i = 0; i < 5; ++i) {
e.execute_cql(sprint("INSERT INTO t2 (p, a, b) VALUES (%s, %s, %s)", i, i * 10, i * 100)).get();
}
queries = {
"SELECT * FROM t2 WHERE p = 1",
"SELECT * FROM t2 WHERE a = 20"
};
for (const sstring& q : queries) {
e.execute_cql(q).get();
e.execute_cql(q + " ALLOW FILTERING").get();
}
queries = {
"SELECT * FROM t2 WHERE a = 20 AND b = 200"
};
for (const sstring& q : queries) {
BOOST_CHECK_THROW(e.execute_cql(q).get(), exceptions::invalid_request_exception);
e.execute_cql(q + " ALLOW FILTERING").get();
}
});
}
SEASTAR_TEST_CASE(test_allow_filtering_pk_ck) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, PRIMARY KEY ((a, b), c, d));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (11, 12, 13, 14, 15)").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (11, 15, 16, 17, 18)").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (21, 22, 23, 24, 25)").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (31, 32, 33, 34, 35)").get();
auto msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c = 16").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 12 AND c > 13 AND d = 14").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c = 16").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c > 13 AND d >= 17 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 12 AND c > 13 AND d > 17").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c > 13 AND d >= 17 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a <= 11 AND c > 15 AND d >= 16 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a <= 11 AND b >= 15 AND c > 15 AND d >= 16 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a <= 100 AND b >= 15 AND c > 0 AND d <= 100 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
},
{
int32_type->decompose(31),
int32_type->decompose(32),
int32_type->decompose(33),
int32_type->decompose(34),
int32_type->decompose(35),
},
{
int32_type->decompose(21),
int32_type->decompose(22),
int32_type->decompose(23),
int32_type->decompose(24),
int32_type->decompose(25),
}
});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE a <= 11 AND c > 15 AND d >= 16").get(), exceptions::invalid_request_exception);
});
}
SEASTAR_TEST_CASE(test_allow_filtering_clustering_column) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (k int, c int, v int, PRIMARY KEY (k, c));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (k, c, v) VALUES (1, 2, 1)").get();
e.execute_cql("INSERT INTO t (k, c, v) VALUES (1, 3, 2)").get();
e.execute_cql("INSERT INTO t (k, c, v) VALUES (2, 2, 3)").get();
auto msg = e.execute_cql("SELECT * FROM t WHERE k = 1").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
},
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2)
}
});
msg = e.execute_cql("SELECT * FROM t WHERE k = 1 AND c > 2").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2)
}});
msg = e.execute_cql("SELECT * FROM t WHERE k = 1 AND c = 2").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c = 2").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c > 2 AND c <= 4").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT * FROM t WHERE c = 2 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
},
{
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(3)
}
});
msg = e.execute_cql("SELECT * FROM t WHERE c > 2 AND c <= 4 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2)
}});
});
}
SEASTAR_TEST_CASE(test_allow_filtering_static_column) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, s int static, PRIMARY KEY(a, b));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("CREATE INDEX ON t(c)").get();
e.execute_cql("INSERT INTO t (a, b, c, s) VALUES (1, 1, 1, 1)").get();
e.execute_cql("INSERT INTO t (a, b, c) VALUES (1, 2, 1)").get();
e.execute_cql("INSERT INTO t (a, s) VALUES (3, 3)").get();
e.execute_cql("INSERT INTO t (a, b, c, s) VALUES (2, 1, 1, 2)").get();
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t WHERE c = 1 AND s = 2 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
}});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t WHERE c = 1 AND s = 1 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1)
},
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(1)
}
});
});
});
}
SEASTAR_TEST_CASE(test_allow_filtering_multiple_regular) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, f list<int>, g set<int>, PRIMARY KEY(a, b));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 1, 1, 1, 1, [1], {})").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 2, 3, 4, 5, [1, 2], {1, 2, 3})").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 3, 5, 1, 9, [1, 2, 3], {1, 2})").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 4, 5, 7, 5, [], {1})").get();
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c = 5").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE d = 1").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE e = 5").get(), exceptions::invalid_request_exception);
// Collection filtering queries are not supported yet
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE f contains 2").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE g contains 1").get(), exceptions::invalid_request_exception);
auto msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 3 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
}});
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE e >= 5 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
},
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
},
{
int32_type->decompose(1),
int32_type->decompose(4),
int32_type->decompose(5),
int32_type->decompose(7),
int32_type->decompose(5)
}
});
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 5 and e = 9 and d = 1 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}});
cql3::prepared_cache_key_type prepared_id = e.prepare("SELECT a, b, c, d, e FROM t WHERE a = ? and d = ? ALLOW FILTERING").get0();
std::vector<cql3::raw_value> raw_values {
cql3::raw_value::make_value(int32_type->decompose(1)),
cql3::raw_value::make_value(int32_type->decompose(1))
};
msg = e.execute_prepared(prepared_id, raw_values).get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1)
},
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}
});
prepared_id = e.prepare("SELECT a, b, c, d, e FROM t WHERE a = ? and d = ? ALLOW FILTERING").get0();
raw_values[1] = cql3::raw_value::make_value(int32_type->decompose(9));
msg = e.execute_prepared(prepared_id, raw_values).get0();
assert_that(msg).is_rows().with_size(0);
});
}
SEASTAR_TEST_CASE(test_allow_filtering_with_secondary_index) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, PRIMARY KEY(a, b));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("CREATE INDEX ON t(c)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 1, 1, 1, 1)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 2, 3, 4, 5)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 3, 5, 1, 9)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 4, 5, 7, 5)").get();
auto msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 3").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c = 5 and d = 1").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 5 and d = 1 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}});
e.execute_cql("CREATE TABLE t2 (pk1 int, pk2 int, c1 int, c2 int, v int, PRIMARY KEY ((pk1, pk2), c1, c2));").get();
e.execute_cql("CREATE INDEX ON t2(v)").get();
for (int i = 1; i <= 5; ++i) {
for (int j = 1; j <= 2; ++j) {
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, 1, 1, 1, i)).get();
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, 1, 1, i, i)).get();
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, 1, i, i, i)).get();
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, i, i, i, i)).get();
}
}
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c1 > 0 AND c1 < 5 AND c2 = 1 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c1 > 0 AND c1 < 5 AND c2 = 3 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3)
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
}
});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c2 > 1 AND c2 < 5 AND v = 1 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c1 > 1 AND c2 > 2 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
}
});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND pk2 > 1 AND c2 > 2 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
}});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 >= 2 AND pk2 <=3 AND c1 IN(0,1,2) AND c2 IN(0,1,2) AND v < 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2)
},
{
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(2)
},
{
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2)
}
});
});
});
}
SEASTAR_TEST_CASE(test_in_restriction_on_not_last_partition_key) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int,b int,c int,d int,PRIMARY KEY ((a, b), c));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,1,1,100); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,1,2,200); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,1,3,300); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,2,1,300); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,3,1,1300);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,3,2,1400);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,3,2,1400);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,1,2,1400);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,1,3,1300);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,2,3,1300);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (3,1,3,1300);").get();
{
auto msg = e.execute_cql("SELECT * FROM t WHERE a IN (1,2) AND b IN (2,3) AND c>=2 AND c<=3;").get0();
assert_that(msg).is_rows().with_rows_ignore_order({
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2),
int32_type->decompose(1400),
},
{
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(1300),
},
{
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(2),
int32_type->decompose(1400),
}
});
}
{
auto msg = e.execute_cql("SELECT * FROM t WHERE a IN (1,3) AND b=1 AND c>=2 AND c<=3;").get0();
assert_that(msg).is_rows().with_rows_ignore_order({
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(200),
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(300),
},
{
int32_type->decompose(3),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(1300),
}
});
}
});
}
SEASTAR_TEST_CASE(test_static_multi_cell_static_lists_with_ckey) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (p int, c int, slist list<int> static, v int, PRIMARY KEY (p, c));").get();
e.execute_cql("INSERT INTO t (p, c, slist, v) VALUES (1, 1, [1], 1); ").get();
{
e.execute_cql("UPDATE t SET slist[0] = 3, v = 3 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({{3}}))) },
{ int32_type->decompose(3) }
});
}
{
e.execute_cql("UPDATE t SET slist = [4], v = 4 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({{4}}))) },
{ int32_type->decompose(4) }
});
}
{
e.execute_cql("UPDATE t SET slist = [3] + slist , v = 5 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3, 4}))) },
{ int32_type->decompose(5) }
});
}
{
e.execute_cql("UPDATE t SET slist = slist + [5] , v = 6 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3, 4, 5}))) },
{ int32_type->decompose(6) }
});
}
{
e.execute_cql("DELETE slist[2] from t WHERE p = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3, 4}))) },
{ int32_type->decompose(6) }
});
}
{
e.execute_cql("UPDATE t SET slist = slist - [4] , v = 7 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3}))) },
{ int32_type->decompose(7) }
});
}
});
}
tests: add test case for filtering with DESC clustering order
Refs #3741
Message-Id: <20b9dd3eae55d4e45f4c8f6c65c80fb54a6ff056@scylladb.com>
/*
* Copyright (C) 2015 ScyllaDB
*/
/*
* This file is part of Scylla.
*
* Scylla is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Scylla is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scylla. If not, see <http://www.gnu.org/licenses/>.
*/
#include <boost/range/irange.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <seastar/net/inet_address.hh>
#include "tests/test-utils.hh"
#include "tests/cql_test_env.hh"
#include "tests/cql_assertions.hh"
#include "core/future-util.hh"
#include "core/sleep.hh"
#include "transport/messages/result_message.hh"
#include "utils/big_decimal.hh"
using namespace std::literals::chrono_literals;
SEASTAR_TEST_CASE(test_create_keyspace_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create keyspace ks2 with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };").discard_result().then([&e] {
return e.require_keyspace_exists("ks2");
});
});
}
SEASTAR_TEST_CASE(test_create_table_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table users (user_name varchar PRIMARY KEY, birth_year bigint);").discard_result().then([&e] {
return e.require_table_exists("ks", "users");
}).then([&e] {
return e.execute_cql("create table cf (id int primary key, m map<int, int>, s set<text>, l list<uuid>);").discard_result();
}).then([&e] {
return e.require_table_exists("ks", "cf");
});
});
}
SEASTAR_TEST_CASE(test_create_table_with_id_statement) {
return do_with_cql_env([](cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE tbl (a int, b int, PRIMARY KEY (a))").get();
auto id = e.local_db().find_schema("ks", "tbl")->id();
e.execute_cql("DROP TABLE tbl").get();
BOOST_REQUIRE_THROW(e.execute_cql("SELECT * FROM tbl").get(), std::exception);
e.execute_cql(
sprint("CREATE TABLE tbl (a int, b int, PRIMARY KEY (a)) WITH id='%s'", id)).get();
assert_that(e.execute_cql("SELECT * FROM tbl").get0())
.is_rows().with_size(0);
BOOST_REQUIRE_THROW(
e.execute_cql(sprint("CREATE TABLE tbl2 (a int, b int, PRIMARY KEY (a)) WITH id='%s'", id)).get(),
std::invalid_argument);
BOOST_REQUIRE_THROW(
e.execute_cql("CREATE TABLE tbl2 (a int, b int, PRIMARY KEY (a)) WITH id='55'").get(),
exceptions::configuration_exception);
BOOST_REQUIRE_THROW(
e.execute_cql("ALTER TABLE tbl WITH id='f2a8c099-e723-48cb-8cd9-53e647a011a3'").get(),
exceptions::configuration_exception);
});
});
}
SEASTAR_TEST_CASE(test_drop_table_with_si_and_mv) {
return do_with_cql_env([](cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE tbl (a int, b int, c float, PRIMARY KEY (a))").get();
e.execute_cql("CREATE INDEX idx1 ON tbl (b)").get();
e.execute_cql("CREATE INDEX idx2 ON tbl (c)").get();
e.execute_cql("CREATE MATERIALIZED VIEW tbl_view AS SELECT c FROM tbl WHERE c IS NOT NULL PRIMARY KEY (c, a)").get();
// dropping a table with materialized views is prohibited
assert_that_failed(e.execute_cql("DROP TABLE tbl"));
e.execute_cql("DROP MATERIALIZED VIEW tbl_view").get();
// dropping a table with secondary indexes is fine
e.execute_cql("DROP TABLE tbl").get();
e.execute_cql("CREATE TABLE tbl (a int, b int, c float, PRIMARY KEY (a))").get();
e.execute_cql("CREATE INDEX idx1 ON tbl (b)").get();
e.execute_cql("CREATE INDEX idx2 ON tbl (c)").get();
e.execute_cql("CREATE MATERIALIZED VIEW tbl_view AS SELECT c FROM tbl WHERE c IS NOT NULL PRIMARY KEY (c, a)").get();
// dropping whole keyspace with MV and SI is fine too
e.execute_cql("DROP KEYSPACE ks").get();
});
});
}
SEASTAR_TEST_CASE(test_insert_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
return e.execute_cql("insert into cf (p1, c1, r1) values ('key1', 1, 100);").discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 100);
}).then([&e] {
return e.execute_cql("update cf set r1 = 66 where p1 = 'key1' and c1 = 1;").discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 66);
});
});
}
SEASTAR_TEST_CASE(test_select_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks_name) {
// CQL: create table cf (p1 varchar, c1 int, c2 int, r1 int, PRIMARY KEY (p1, c1, c2));
return schema({}, ks_name, "cf",
{{"p1", utf8_type}},
{{"c1", int32_type}, {"c2", int32_type}},
{{"r1", int32_type}},
{},
utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, c2, r1) values ('key1', 1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, c2, r1) values ('key2', 1, 2, 13);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, c2, r1) values ('key3', 1, 2, 23);").discard_result();
}).then([&e] {
// Test wildcard
return e.execute_cql("select * from cf where p1 = 'key1' and c2 = 2 and c1 = 1;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)}
});
});
}).then([&e] {
// Test with only regular column
return e.execute_cql("select r1 from cf where p1 = 'key1' and c2 = 2 and c1 = 1;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{int32_type->decompose(3)}
});
});
}).then([&e] {
// Test full partition range, singular clustering range
return e.execute_cql("select * from cf where c1 = 1 and c2 = 2 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(3)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)}})
.with_row({
{utf8_type->decompose(sstring("key2"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(13)}})
.with_row({
{utf8_type->decompose(sstring("key3"))},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(23)}
});
});
});
});
}
SEASTAR_TEST_CASE(test_cassandra_stress_like_write_and_read) {
return do_with_cql_env([] (cql_test_env& e) {
auto execute_update_for_key = [&e](sstring key) {
return e.execute_cql(sprint("UPDATE cf SET "
"\"C0\" = 0x8f75da6b3dcec90c8a404fb9a5f6b0621e62d39c69ba5758e5f41b78311fbb26cc7a,"
"\"C1\" = 0xa8761a2127160003033a8f4f3d1069b7833ebe24ef56b3beee728c2b686ca516fa51,"
"\"C2\" = 0x583449ce81bfebc2e1a695eb59aad5fcc74d6d7311fc6197b10693e1a161ca2e1c64,"
"\"C3\" = 0x62bcb1dbc0ff953abc703bcb63ea954f437064c0c45366799658bd6b91d0f92908d7,"
"\"C4\" = 0x222fcbe31ffa1e689540e1499b87fa3f9c781065fccd10e4772b4c7039c2efd0fb27 "
"WHERE \"KEY\"=%s;", key)).discard_result();
};
auto verify_row_for_key = [&e](sstring key) {
return e.execute_cql(
sprint("select \"C0\", \"C1\", \"C2\", \"C3\", \"C4\" from cf where \"KEY\" = %s", key)).then(
[](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{from_hex(
"8f75da6b3dcec90c8a404fb9a5f6b0621e62d39c69ba5758e5f41b78311fbb26cc7a")},
{from_hex(
"a8761a2127160003033a8f4f3d1069b7833ebe24ef56b3beee728c2b686ca516fa51")},
{from_hex(
"583449ce81bfebc2e1a695eb59aad5fcc74d6d7311fc6197b10693e1a161ca2e1c64")},
{from_hex(
"62bcb1dbc0ff953abc703bcb63ea954f437064c0c45366799658bd6b91d0f92908d7")},
{from_hex("222fcbe31ffa1e689540e1499b87fa3f9c781065fccd10e4772b4c7039c2efd0fb27")}
});
});
};
return e.create_table([](sstring ks_name) {
return schema({}, ks_name, "cf",
{{"KEY", bytes_type}},
{},
{{"C0", bytes_type},
{"C1", bytes_type},
{"C2", bytes_type},
{"C3", bytes_type},
{"C4", bytes_type}},
{},
utf8_type);
}).then([execute_update_for_key, verify_row_for_key] {
static auto make_key = [](int suffix) { return sprint("0xdeadbeefcafebabe%02d", suffix); };
auto suffixes = boost::irange(0, 10);
return parallel_for_each(suffixes.begin(), suffixes.end(), [execute_update_for_key](int suffix) {
return execute_update_for_key(make_key(suffix));
}).then([suffixes, verify_row_for_key] {
return parallel_for_each(suffixes.begin(), suffixes.end(), [verify_row_for_key](int suffix) {
return verify_row_for_key(make_key(suffix));
});
});
});
});
}
SEASTAR_TEST_CASE(test_range_queries) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks_name) {
return schema({}, ks_name, "cf",
{{"k", bytes_type}},
{{"c0", bytes_type}, {"c1", bytes_type}},
{{"v", bytes_type}},
{},
utf8_type);
}).then([&e] {
return e.execute_cql("update cf set v = 0x01 where k = 0x00 and c0 = 0x01 and c1 = 0x01;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x02 where k = 0x00 and c0 = 0x01 and c1 = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x03 where k = 0x00 and c0 = 0x01 and c1 = 0x03;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x04 where k = 0x00 and c0 = 0x02 and c1 = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x05 where k = 0x00 and c0 = 0x02 and c1 = 0x03;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x06 where k = 0x00 and c0 = 0x02 and c1 = 0x04;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x07 where k = 0x00 and c0 = 0x03 and c1 = 0x04;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x08 where k = 0x00 and c0 = 0x03 and c1 = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({
{from_hex("01")},
{from_hex("02")},
{from_hex("03")},
{from_hex("04")},
{from_hex("05")},
{from_hex("06")},
{from_hex("07")},
{from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 = 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 > 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("07")}, {from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 >= 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}, {from_hex("07")}, {from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 >= 0x02 and c0 < 0x03 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 > 0x02 and c0 <= 0x03 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("07")}, {from_hex("08")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 >= 0x02 and c0 <= 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}, {from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 < 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")}, {from_hex("02")}, {from_hex("03")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 = 0x02 and c1 > 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("05")}, {from_hex("06")}
});
});
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 and c0 = 0x02 and c1 >= 0x02 and c1 <= 0x02 allow filtering;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_ordering_of_composites_with_variable_length_components) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks) {
return schema({}, ks, "cf",
{{"k", bytes_type}},
// We need more than one clustering column so that the single-element tuple format optimisation doesn't kick in
{{"c0", bytes_type}, {"c1", bytes_type}},
{{"v", bytes_type}},
{},
utf8_type);
}).then([&e] {
return e.execute_cql("update cf set v = 0x01 where k = 0x00 and c0 = 0x0001 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x02 where k = 0x00 and c0 = 0x03 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x03 where k = 0x00 and c0 = 0x035555 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x04 where k = 0x00 and c0 = 0x05 and c1 = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf where k = 0x00 allow filtering;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")}, {from_hex("02")}, {from_hex("03")}, {from_hex("04")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_query_with_static_columns) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, c blob, v blob, s1 blob static, s2 blob static, primary key (k, c));").discard_result().then([&e] {
return e.execute_cql("update cf set s1 = 0x01 where k = 0x00;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x02 where k = 0x00 and c = 0x01;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set v = 0x03 where k = 0x00 and c = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("select s1, v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")},
{from_hex("01"), from_hex("03")},
});
});
}).then([&e] {
return e.execute_cql("select s1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("select s1 from cf limit 1;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("select s1, v from cf limit 1;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")},
});
});
}).then([&e] {
return e.execute_cql("update cf set v = null where k = 0x00 and c = 0x02;").discard_result();
}).then([&e] {
return e.execute_cql("select s1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("insert into cf (k, c) values (0x00, 0x02);").discard_result();
}).then([&e] {
return e.execute_cql("select s1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
{from_hex("01")},
});
});
}).then([&e] {
// Try 'in' restriction out
return e.execute_cql("select s1, v from cf where k = 0x00 and c in (0x01, 0x02);").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")},
{from_hex("01"), {}}
});
});
}).then([&e] {
// Verify that limit is respected for multiple clustering ranges and that static columns
// are populated when limit kicks in.
return e.execute_cql("select s1, v from cf where k = 0x00 and c in (0x01, 0x02) limit 1;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), from_hex("02")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_insert_without_clustering_key) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, v blob, primary key (k));").discard_result().then([&e] {
return e.execute_cql("insert into cf (k) values (0x01);").discard_result();
}).then([&e] {
return e.execute_cql("select * from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01"), {}}
});
});
}).then([&e] {
return e.execute_cql("select k from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")}
});
});
});
});
}
SEASTAR_TEST_CASE(test_limit_is_respected_across_partitions) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, c blob, v blob, s1 blob static, primary key (k, c));").discard_result().then([&e] {
return e.execute_cql("update cf set s1 = 0x01 where k = 0x01;").discard_result();
}).then([&e] {
return e.execute_cql("update cf set s1 = 0x02 where k = 0x02;").discard_result();
}).then([&e] {
// Determine partition order
return e.execute_cql("select k from cf;");
}).then([&e](shared_ptr<cql_transport::messages::result_message> msg) {
auto rows = dynamic_pointer_cast<cql_transport::messages::result_message::rows>(msg);
BOOST_REQUIRE(rows);
std::vector<bytes> keys;
auto rs = rows->rs().result_set();
for (auto&& row : rs.rows()) {
BOOST_REQUIRE(row[0]);
keys.push_back(*row[0]);
}
BOOST_REQUIRE(keys.size() == 2);
bytes k1 = keys[0];
bytes k2 = keys[1];
return now().then([k1, k2, &e] {
return e.execute_cql("select s1 from cf limit 1;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{k1},
});
});
}).then([&e, k1, k2] {
return e.execute_cql("select s1 from cf limit 2;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{k1}, {k2}
});
});
}).then([&e, k1, k2] {
return e.execute_cql(sprint("update cf set s1 = null where k = 0x%s;", to_hex(k1))).discard_result();
}).then([&e, k1, k2] {
return e.execute_cql("select s1 from cf limit 1;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{k2}
});
});
}).then([&e, k1, k2] {
return e.execute_cql(sprint("update cf set s1 = null where k = 0x%s;", to_hex(k2))).discard_result();
}).then([&e, k1, k2] {
return e.execute_cql("select s1 from cf limit 1;").then([k1, k2](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
});
});
});
}
SEASTAR_TEST_CASE(test_partitions_have_consistent_ordering_in_range_query) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, v int, primary key (k));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (k, v) values (0x01, 0); \n"
" insert into cf (k, v) values (0x02, 0); \n"
" insert into cf (k, v) values (0x03, 0); \n"
" insert into cf (k, v) values (0x04, 0); \n"
" insert into cf (k, v) values (0x05, 0); \n"
" insert into cf (k, v) values (0x06, 0); \n"
"apply batch;"
).discard_result();
}).then([&e] {
// Determine partition order
return e.execute_cql("select k from cf;");
}).then([&e](shared_ptr<cql_transport::messages::result_message> msg) {
auto rows = dynamic_pointer_cast<cql_transport::messages::result_message::rows>(msg);
BOOST_REQUIRE(rows);
std::vector<bytes> keys;
auto rs = rows->rs().result_set();
for (auto&& row : rs.rows()) {
BOOST_REQUIRE(row[0]);
keys.push_back(*row[0]);
}
BOOST_REQUIRE(keys.size() == 6);
return now().then([keys, &e] {
return e.execute_cql("select k from cf limit 1;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 2;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 3;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 4;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 5;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]}
});
});
}).then([keys, &e] {
return e.execute_cql("select k from cf limit 6;").then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]},
{keys[5]}
});
});
});
});
});
}
SEASTAR_TEST_CASE(test_partition_range_queries_with_bounds) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (k blob, v int, primary key (k));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (k, v) values (0x01, 0); \n"
" insert into cf (k, v) values (0x02, 0); \n"
" insert into cf (k, v) values (0x03, 0); \n"
" insert into cf (k, v) values (0x04, 0); \n"
" insert into cf (k, v) values (0x05, 0); \n"
"apply batch;"
).discard_result();
}).then([&e] {
// Determine partition order
return e.execute_cql("select k, token(k) from cf;");
}).then([&e](shared_ptr<cql_transport::messages::result_message> msg) {
auto rows = dynamic_pointer_cast<cql_transport::messages::result_message::rows>(msg);
BOOST_REQUIRE(rows);
std::vector<bytes> keys;
std::vector<int64_t> tokens;
auto rs = rows->rs().result_set();
for (auto&& row : rs.rows()) {
BOOST_REQUIRE(row[0]);
BOOST_REQUIRE(row[1]);
keys.push_back(*row[0]);
tokens.push_back(value_cast<int64_t>(long_type->deserialize(*row[1])));
}
BOOST_REQUIRE(keys.size() == 5);
return now().then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) > %d;", tokens[1])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[2]},
{keys[3]},
{keys[4]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) >= %ld;", tokens[1])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) > %ld and token(k) < %ld;",
tokens[1], tokens[4])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[2]},
{keys[3]},
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) < %ld;", tokens[3])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) = %ld;", tokens[3])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[3]}
});
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) < %ld and token(k) > %ld;", tokens[3], tokens[3])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([keys, tokens, &e] {
return e.execute_cql(sprint("select k from cf where token(k) >= %ld and token(k) <= %ld;", tokens[4], tokens[2])).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([keys, tokens, &e] {
auto min_token = std::numeric_limits<int64_t>::min();
return e.execute_cql(sprint("select k from cf where token(k) > %ld and token (k) < %ld;", min_token, min_token)).then([keys](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{keys[0]},
{keys[1]},
{keys[2]},
{keys[3]},
{keys[4]}
});
});
});
});
});
}
SEASTAR_TEST_CASE(test_deletion_scenarios) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks) {
// CQL: create table cf (k bytes, c bytes, v bytes, primary key (k, c));
return schema({}, ks, "cf",
{{"k", bytes_type}}, {{"c", bytes_type}}, {{"v", bytes_type}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (k, c, v) values (0x00, 0x05, 0x01) using timestamp 1;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("01")},
});
});
}).then([&e] {
return e.execute_cql("update cf using timestamp 2 set v = null where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{{}},
});
});
}).then([&e] {
// same tampstamp, dead cell wins
return e.execute_cql("update cf using timestamp 2 set v = 0x02 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{{}},
});
});
}).then([&e] {
return e.execute_cql("update cf using timestamp 3 set v = 0x02 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("02")},
});
});
}).then([&e] {
// same timestamp, greater value wins
return e.execute_cql("update cf using timestamp 3 set v = 0x03 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("03")},
});
});
}).then([&e] {
// same tampstamp, delete whole row, delete should win
return e.execute_cql("delete from cf using timestamp 3 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([&e] {
// same timestamp, update should be shadowed by range tombstone
return e.execute_cql("update cf using timestamp 3 set v = 0x04 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
}).then([&e] {
return e.execute_cql("update cf using timestamp 4 set v = 0x04 where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{from_hex("04")},
});
});
}).then([&e] {
// deleting an orphan cell (row is considered as deleted) yields no row
return e.execute_cql("update cf using timestamp 5 set v = null where k = 0x00 and c = 0x05;").discard_result();
}).then([&e] {
return e.execute_cql("select v from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().is_empty();
});
});
});
}
SEASTAR_TEST_CASE(test_range_deletion_scenarios) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("create table cf (p int, c int, v text, primary key (p, c));").get();
for (auto i = 0; i < 10; ++i) {
e.execute_cql(sprint("insert into cf (p, c, v) values (1, %d, 'abc');", i)).get();
}
try {
e.execute_cql("delete from cf where p = 1 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
e.execute_cql("delete from cf where p = 1 and c >= 0 and c <= 3").get();
auto msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_size(6);
e.execute_cql("delete from cf where p = 1 and c > 3 and c < 10").get();
msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_size(0);
e.execute_cql("insert into cf (p, c, v) values (1, 1, '1');").get();
e.execute_cql("insert into cf (p, c, v) values (1, 3, '3');").get();
e.execute_cql("delete from cf where p = 1 and c >= 2 and c <= 3").get();
e.execute_cql("insert into cf (p, c, v) values (1, 2, '2');").get();
msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_size(2);
e.execute_cql("delete from cf where p = 1 and c >= 2 and c <= 3").get();
msg = e.execute_cql("select * from cf").get0();
assert_that(msg).is_rows().with_rows({{ {int32_type->decompose(1)}, {int32_type->decompose(1)}, {utf8_type->decompose("1")} }});
});
}
SEASTAR_TEST_CASE(test_range_deletion_scenarios_with_compact_storage) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("create table cf (p int, c int, v text, primary key (p, c)) with compact storage;").get();
for (auto i = 0; i < 10; ++i) {
e.execute_cql(sprint("insert into cf (p, c, v) values (1, %d, 'abc');", i)).get();
}
try {
e.execute_cql("delete from cf where p = 1 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c > 0 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0 and c < 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c > 0 and c < 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
try {
e.execute_cql("delete from cf where p = 1 and c >= 0 and c <= 3").get();
BOOST_FAIL("should've thrown");
} catch (...) { }
});
}
SEASTAR_TEST_CASE(test_map_insert_update) {
return do_with_cql_env([] (cql_test_env& e) {
auto make_my_map_type = [] { return map_type_impl::get_instance(int32_type, int32_type, true); };
auto my_map_type = make_my_map_type();
return e.create_table([make_my_map_type] (sstring ks_name) {
// CQL: create table cf (p1 varchar primary key, map1 map<int, int>);
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {}, {{"map1", make_my_map_type()}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, map1) values ('key1', { 1001: 2001 });").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type, map_type_impl::native_type({{1001, 2001}})));
}).then([&e] {
return e.execute_cql("update cf set map1[1002] = 2002 where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1001, 2001},
{1002, 2002}})));
}).then([&e] {
// overwrite an element
return e.execute_cql("update cf set map1[1001] = 3001 where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1001, 3001},
{1002, 2002}})));
}).then([&e] {
// overwrite whole map
return e.execute_cql("update cf set map1 = {1003: 4003} where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1003, 4003}})));
}).then([&e] {
// overwrite whole map, but bad syntax
return e.execute_cql("update cf set map1 = {1003, 4003} where p1 = 'key1';");
}).then_wrapped([](future<shared_ptr<cql_transport::messages::result_message>> f) {
BOOST_REQUIRE(f.failed());
std::move(f).discard_result();
}).then([&e] {
// overwrite whole map
return e.execute_cql(
"update cf set map1 = {1001: 5001, 1002: 5002, 1003: 5003} where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{1001, 5001},
{1002, 5002},
{1003, 5003}})));
}).then([&e] {
// discard some keys
return e.execute_cql("update cf set map1 = map1 - {1001, 1003, 1005} where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{{1002, 5002}}})));
}).then([&e, my_map_type] {
return e.execute_cql("select * from cf where p1 = 'key1';").then([my_map_type](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{my_map_type->decompose(make_map_value(my_map_type, map_type_impl::native_type{{{1002, 5002}}}))},
});
});
}).then([&e] {
// overwrite an element
return e.execute_cql("update cf set map1[1009] = 5009 where p1 = 'key1';").discard_result();
}).then([&e] {
// delete a key
return e.execute_cql("delete map1[1002] from cf where p1 = 'key1';").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type,
map_type_impl::native_type({{{1009, 5009}}})));
}).then([&e] {
return e.execute_cql("insert into cf (p1, map1) values ('key1', null);").discard_result();
}).then([&e, my_map_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"map1", make_map_value(my_map_type, map_type_impl::native_type({})));
});
});
}
SEASTAR_TEST_CASE(test_set_insert_update) {
return do_with_cql_env([] (cql_test_env& e) {
auto make_my_set_type = [] { return set_type_impl::get_instance(int32_type, true); };
auto my_set_type = make_my_set_type();
return e.create_table([make_my_set_type](sstring ks_name) {
// CQL: create table cf (p1 varchar primary key, set1 set<int>);
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {}, {{"set1", make_my_set_type()}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, set1) values ('key1', { 1001 });").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({{1001}})));
}).then([&e] {
return e.execute_cql("update cf set set1 = set1 + { 1002 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({1001, 1002})));
}).then([&e] {
// overwrite an element
return e.execute_cql("update cf set set1 = set1 + { 1001 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({1001, 1002})));
}).then([&e] {
// overwrite entire set
return e.execute_cql("update cf set set1 = { 1007, 1019 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({1007, 1019})));
}).then([&e] {
// discard keys
return e.execute_cql("update cf set set1 = set1 - { 1007, 1008 } where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({{1019}})));
}).then([&e, my_set_type] {
return e.execute_cql("select * from cf where p1 = 'key1';").then([my_set_type](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{my_set_type->decompose(make_set_value(my_set_type, set_type_impl::native_type{{1019}}))},
});
});
}).then([&e] {
return e.execute_cql("update cf set set1 = set1 + { 1009 } where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql("delete set1[1019] from cf where p1 = 'key1';").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({{1009}})));
}).then([&e] {
return e.execute_cql("insert into cf (p1, set1) values ('key1', null);").discard_result();
}).then([&e, my_set_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"set1", make_set_value(my_set_type, set_type_impl::native_type({})));
});
});
}
SEASTAR_TEST_CASE(test_list_insert_update) {
return do_with_cql_env([] (cql_test_env& e) {
auto my_list_type = list_type_impl::get_instance(int32_type, true);
return e.execute_cql("create table cf (p1 varchar primary key, list1 list<int>);").discard_result().then([&e] {
return e.execute_cql("insert into cf (p1, list1) values ('key1', [ 1001 ]);").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({{1001}})));
}).then([&e] {
return e.execute_cql("update cf set list1 = [ 1002, 1003 ] where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({1002, 1003})));
}).then([&e] {
return e.execute_cql("update cf set list1[1] = 2003 where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({1002, 2003})));
}).then([&e] {
return e.execute_cql("update cf set list1 = list1 - [1002, 2004] where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({{2003}})));
}).then([&e, my_list_type] {
return e.execute_cql("select * from cf where p1 = 'key1';").then([my_list_type] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{utf8_type->decompose(sstring("key1"))},
{my_list_type->decompose(make_list_value(my_list_type, list_type_impl::native_type({{2003}})))},
});
});
}).then([&e] {
return e.execute_cql("update cf set list1 = [2008, 2009, 2010] where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql("delete list1[1] from cf where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({2008, 2010})));
}).then([&e] {
return e.execute_cql("update cf set list1 = list1 + [2012, 2019] where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({2008, 2010, 2012, 2019})));
}).then([&e] {
return e.execute_cql("update cf set list1 = [2001, 2002] + list1 where p1 = 'key1';").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({2001, 2002, 2008, 2010, 2012, 2019})));
}).then([&e] {
return e.execute_cql("insert into cf (p1, list1) values ('key1', null);").discard_result();
}).then([&e, my_list_type] {
return e.require_column_has_value("cf", {sstring("key1")}, {},
"list1", make_list_value(my_list_type, list_type_impl::native_type({})));
});
});
}
SEASTAR_TEST_CASE(test_functions) {
return do_with_cql_env([] (cql_test_env& e) {
return e.create_table([](sstring ks_name) {
// CQL: create table cf (p1 varchar primary key, u uuid, tu timeuuid);
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {{"c1", int32_type}}, {{"tu", timeuuid_type}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, tu) values ('key1', 1, now());").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, tu) values ('key1', 2, now());").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, c1, tu) values ('key1', 3, now());").discard_result();
}).then([&e] {
return e.execute_cql("select tu from cf where p1 in ('key1');");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
using namespace cql_transport::messages;
struct validator : result_message::visitor {
std::vector<bytes_opt> res;
virtual void visit(const result_message::void_message&) override { throw "bad"; }
virtual void visit(const result_message::set_keyspace&) override { throw "bad"; }
virtual void visit(const result_message::prepared::cql&) override { throw "bad"; }
virtual void visit(const result_message::prepared::thrift&) override { throw "bad"; }
virtual void visit(const result_message::schema_change&) override { throw "bad"; }
virtual void visit(const result_message::rows& rows) override {
auto rs = rows.rs().result_set();
BOOST_REQUIRE_EQUAL(rs.rows().size(), 3);
for (auto&& rw : rs.rows()) {
BOOST_REQUIRE_EQUAL(rw.size(), 1);
res.push_back(rw[0]);
}
}
};
validator v;
msg->accept(v);
// No boost::adaptors::sorted
boost::sort(v.res);
BOOST_REQUIRE_EQUAL(boost::distance(v.res | boost::adaptors::uniqued), 3);
}).then([&] {
return e.execute_cql("select sum(c1), count(c1) from cf where p1 = 'key1';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{int32_type->decompose(6)},
{long_type->decompose(3L)},
});
}).then([&] {
return e.execute_cql("select count(*) from cf where p1 = 'key1';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{long_type->decompose(3L)},
});
}).then([&] {
return e.execute_cql("select count(1) from cf where p1 = 'key1';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{long_type->decompose(3L)},
});
}).then([&e] {
// Inane, casting to own type, but couldn't find more interesting example
return e.execute_cql("insert into cf (p1, c1) values ((text)'key2', 7);").discard_result();
}).then([&e] {
return e.execute_cql("select c1 from cf where p1 = 'key2';");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_size(1)
.with_row({
{int32_type->decompose(7)},
});
});
});
}
static const api::timestamp_type the_timestamp = 123456789;
SEASTAR_TEST_CASE(test_writetime_and_ttl) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar primary key, i int);").discard_result().then([&e] {
auto q = sprint("insert into cf (p1, i) values ('key1', 1) using timestamp %d;", the_timestamp);
return e.execute_cql(q).discard_result();
}).then([&e] {
return e.execute_cql("select writetime(i) from cf where p1 in ('key1');");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({{
{long_type->decompose(int64_t(the_timestamp))},
}});
});
});
}
SEASTAR_TEST_CASE(test_batch) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (p1, c1, r1) values ('key1', 1, 100); \n"
" insert into cf (p1, c1, r1) values ('key1', 2, 200); \n"
"apply batch;"
).discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 100);
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {2}, "r1", 200);
});
});
}
SEASTAR_TEST_CASE(test_tuples) {
auto make_tt = [] { return tuple_type_impl::get_instance({int32_type, long_type, utf8_type}); };
auto tt = make_tt();
return do_with_cql_env([tt, make_tt] (cql_test_env& e) {
return e.create_table([make_tt] (sstring ks_name) {
// this runs on all cores, so create a local tt for each core:
auto tt = make_tt();
// CQL: "create table cf (id int primary key, t tuple<int, bigint, text>);
return schema({}, ks_name, "cf",
{{"id", int32_type}}, {}, {{"t", tt}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql("insert into cf (id, t) values (1, (1001, 2001, 'abc1'));").discard_result();
}).then([&e] {
return e.execute_cql("select t from cf where id = 1;");
}).then([&e, tt] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({{
{tt->decompose(make_tuple_value(tt, tuple_type_impl::native_type({int32_t(1001), int64_t(2001), sstring("abc1")})))},
}});
return e.execute_cql("create table cf2 (p1 int PRIMARY KEY, r1 tuple<int, bigint, text>)").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values (1, (1, 2, 'abc'));").discard_result();
}).then([&e] {
return e.execute_cql("select * from cf2 where p1 = 1;");
}).then([&e, tt] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(int32_t(1)), tt->decompose(make_tuple_value(tt, tuple_type_impl::native_type({int32_t(1), int64_t(2), sstring("abc")}))) }
});
});
});
}
SEASTAR_TEST_CASE(test_user_type) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create type ut1 (my_int int, my_bigint bigint, my_text text);").discard_result().then([&e] {
return e.execute_cql("create table cf (id int primary key, t frozen <ut1>);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (id, t) values (1, (1001, 2001, 'abc1'));").discard_result();
}).then([&e] {
return e.execute_cql("select t.my_int, t.my_bigint, t.my_text from cf where id = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({
{int32_type->decompose(int32_t(1001)), long_type->decompose(int64_t(2001)), utf8_type->decompose(sstring("abc1"))},
});
}).then([&e] {
return e.execute_cql("update cf set t = { my_int: 1002, my_bigint: 2002, my_text: 'abc2' } where id = 1;").discard_result();
}).then([&e] {
return e.execute_cql("select t.my_int, t.my_bigint, t.my_text from cf where id = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows()
.with_rows({
{int32_type->decompose(int32_t(1002)), long_type->decompose(int64_t(2002)), utf8_type->decompose(sstring("abc2"))},
});
}).then([&e] {
return e.execute_cql("insert into cf (id, t) values (2, (frozen<ut1>)(2001, 3001, 'abc4'));").discard_result();
}).then([&e] {
return e.execute_cql("select t from cf where id = 2;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
auto ut = user_type_impl::get_instance("ks", to_bytes("ut1"),
{to_bytes("my_int"), to_bytes("my_bigint"), to_bytes("my_text")},
{int32_type, long_type, utf8_type});
auto ut_val = make_user_value(ut,
user_type_impl::native_type({int32_t(2001),
int64_t(3001),
sstring("abc4")}));
assert_that(msg).is_rows()
.with_rows({
{ut->decompose(ut_val)},
});
});
});
}
//
// Since durations don't have a well-defined ordering on their semantic value, a number of restrictions exist on their
// use.
//
SEASTAR_TEST_CASE(test_duration_restrictions) {
auto validate_request_failure = [] (cql_test_env& env, const sstring& request, const sstring& expected_message) {
return futurize_apply([&] { return env.execute_cql(request); }).then_wrapped([expected_message] (future<shared_ptr<cql_transport::messages::result_message>> f) {
BOOST_REQUIRE_EXCEPTION(f.get(),
exceptions::invalid_request_exception,
[&expected_message](const exceptions::invalid_request_exception& ire) {
BOOST_REQUIRE_EQUAL(expected_message, ire.what());
return true;
});
});
};
return do_with_cql_env([&] (cql_test_env& env) {
return make_ready_future<>().then([&] {
// Disallow "direct" use of durations in ordered collection types to avoid user confusion when their
// ordering doesn't match expectations.
return make_ready_future<>().then([&] {
return validate_request_failure(
env,
"create type my_type (a set<duration>);",
"Durations are not allowed inside sets: set<duration>");
}).then([&] {
return validate_request_failure(
env,
"create type my_type (a map<duration, int>);",
"Durations are not allowed as map keys: map<duration, int>");
});
}).then([&] {
// Disallow any type referring to a duration from being used in a primary key of a table or a materialized
// view.
return make_ready_future<>().then([&] {
return validate_request_failure(
env,
"create table my_table (direct_key duration PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part direct_key");
}).then([&] {
return validate_request_failure(
env,
"create table my_table (collection_key frozen<list<duration>> PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part collection_key");
}).then([&] {
return env.execute_cql("create type my_type0 (span duration);").discard_result().then([&] {
return validate_request_failure(
env,
"create table my_table (udt_key frozen<my_type0> PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part udt_key");
});
}).then([&] {
return validate_request_failure(
env,
"create table my_table (tuple_key tuple<int, duration, int> PRIMARY KEY);",
"duration type is not supported for PRIMARY KEY part tuple_key");
}).then([&] {
return env.execute_cql("create table my_table0 (key int PRIMARY KEY, name text, span duration);")
.discard_result().then([&] {
return validate_request_failure(
env,
"create materialized view my_mv as"
" select * from my_table0 "
" primary key (key, span);",
"Cannot use Duration column 'span' in PRIMARY KEY of materialized view");
});
});
}).then([&] {
// Disallow creating secondary indexes on durations.
return validate_request_failure(
env,
"create index my_index on my_table0 (span);",
"Secondary indexes are not supported on duration columns");
}).then([&] {
// Disallow slice-based restrictions and conditions on durations.
//
// Note that multi-column restrictions are only supported on clustering columns (which cannot be `duration`)
// and that multi-column conditions are not supported in the grammar.
return make_ready_future<>().then([&] {
return validate_request_failure(
env,
"select * from my_table0 where key = 0 and span < 3d;",
"Slice restrictions are not supported on duration columns");
}).then([&] {
return validate_request_failure(
env,
"update my_table0 set name = 'joe' where key = 0 if span >= 5m",
"Slice conditions are not supported on durations");
});
});
});
}
SEASTAR_TEST_CASE(test_select_multiple_ranges) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, r1 int, PRIMARY KEY (p1));").discard_result().then([&e] {
return e.execute_cql(
"begin unlogged batch \n"
" insert into cf (p1, r1) values ('key1', 100); \n"
" insert into cf (p1, r1) values ('key2', 200); \n"
"apply batch;"
).discard_result();
}).then([&e] {
return e.execute_cql("select r1 from cf where p1 in ('key1', 'key2');");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2).with_row({
{int32_type->decompose(100)}
}).with_row({
{int32_type->decompose(200)}
});
});
});
}
SEASTAR_TEST_CASE(test_validate_keyspace) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql("create keyspace kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkssssssssssssssssssssssssssssssssssssssssssssss with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace ks3-1 with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace ks3 with replication = { 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace ks3 with rreplication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create keyspace SyStEm with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
});
});
}
SEASTAR_TEST_CASE(test_validate_table) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql("create table ttttttttttttttttttttttttttttttttttttttttbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb (foo text PRIMARY KEY, bar text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, foo text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb-1 (foo text PRIMARY KEY, bar text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text, bar text);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text PRIMARY KEY);");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text) with commment = 'aaaa';");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text) with min_index_interval = -1;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb (foo text PRIMARY KEY, bar text) with min_index_interval = 1024 and max_index_interval = 128;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
});
});
}
SEASTAR_TEST_CASE(test_table_compression) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql("create table tb1 (foo text PRIMARY KEY, bar text) with compression = { };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb1");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb1")->get_compressor_params().get_compressor() == nullptr);
return e.execute_cql("create table tb5 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : '' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb5");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb5")->get_compressor_params().get_compressor() == nullptr);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LossyCompressor' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LZ4Compressor', 'chunk_length_kb' : -1 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LZ4Compressor', 'chunk_length_kb' : 3 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("create table tb2 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'LZ4Compressor', 'chunk_length_kb' : 2 };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb2");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb2")->get_compressor_params().get_compressor() == compressor::lz4);
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb2")->get_compressor_params().chunk_length() == 2 * 1024);
return e.execute_cql("create table tb3 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'DeflateCompressor' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb3");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb3")->get_compressor_params().get_compressor() == compressor::deflate);
return e.execute_cql("create table tb4 (foo text PRIMARY KEY, bar text) with compression = { 'sstable_compression' : 'org.apache.cassandra.io.compress.DeflateCompressor' };");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert(!f.failed());
e.require_table_exists("ks", "tb4");
BOOST_REQUIRE(e.local_db().find_schema("ks", "tb4")->get_compressor_params().get_compressor() == compressor::deflate);
});
});
}
SEASTAR_TEST_CASE(test_ttl) {
return do_with_cql_env([] (cql_test_env& e) {
auto make_my_list_type = [] { return list_type_impl::get_instance(utf8_type, true); };
auto my_list_type = make_my_list_type();
return e.create_table([make_my_list_type] (sstring ks_name) {
return schema({}, ks_name, "cf",
{{"p1", utf8_type}}, {}, {{"r1", utf8_type}, {"r2", utf8_type}, {"r3", make_my_list_type()}}, {}, utf8_type);
}).then([&e] {
return e.execute_cql(
"update cf using ttl 100000 set r1 = 'value1_1', r3 = ['a', 'b', 'c'] where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql(
"update cf using ttl 100 set r1 = 'value1_3', r3 = ['a', 'b', 'c'] where p1 = 'key3';").discard_result();
}).then([&e] {
return e.execute_cql("update cf using ttl 100 set r3[1] = 'b' where p1 = 'key1';").discard_result();
}).then([&e] {
return e.execute_cql("update cf using ttl 100 set r1 = 'value1_2' where p1 = 'key2';").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf (p1, r2) values ('key2', 'value2_2');").discard_result();
}).then([&e, my_list_type] {
return e.execute_cql("select r1 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({utf8_type->decompose(sstring("value1_1"))})
.with_row({utf8_type->decompose(sstring("value1_2"))})
.with_row({utf8_type->decompose(sstring("value1_3"))});
});
}).then([&e, my_list_type] {
return e.execute_cql("select r3 from cf where p1 = 'key1';").then([my_list_type] (shared_ptr<cql_transport::messages::result_message> msg) {
auto my_list_type = list_type_impl::get_instance(utf8_type, true);
assert_that(msg).is_rows().with_rows({
{my_list_type->decompose(make_list_value(my_list_type, list_type_impl::native_type{{sstring("a"), sstring("b"), sstring("c")}}))}
});
});
}).then([&e] {
forward_jump_clocks(200s);
return e.execute_cql("select r1, r2 from cf;").then([](shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2)
.with_row({{}, utf8_type->decompose(sstring("value2_2"))})
.with_row({utf8_type->decompose(sstring("value1_1")), {}});
});
}).then([&e] {
return e.execute_cql("select r2 from cf;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2)
.with_row({ utf8_type->decompose(sstring("value2_2")) })
.with_row({ {} });
});
}).then([&e] {
return e.execute_cql("select r1 from cf;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(2)
.with_row({ {} })
.with_row({ utf8_type->decompose(sstring("value1_1")) });
});
}).then([&e, my_list_type] {
return e.execute_cql("select r3 from cf where p1 = 'key1';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
auto my_list_type = list_type_impl::get_instance(utf8_type, true);
assert_that(msg).is_rows().with_rows({
{my_list_type->decompose(make_list_value(my_list_type, list_type_impl::native_type{{sstring("a"), sstring("c")}}))}
});
});
}).then([&e] {
return e.execute_cql("create table cf2 (p1 text PRIMARY KEY, r1 text, r2 text);").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values ('foo', 'bar') using ttl 500;").discard_result();
}).then([&e] {
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{utf8_type->decompose(sstring("foo")), utf8_type->decompose(sstring("bar"))}
});
});
}).then([&e] {
forward_jump_clocks(600s);
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
}).then([&e] {
return e.execute_cql("select p1, r1 from cf2;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
}).then([&e] {
return e.execute_cql("select count(*) from cf2;").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{long_type->decompose(int64_t(0))}
});
});
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values ('foo', 'bar') using ttl 500;").discard_result();
}).then([&e] {
return e.execute_cql("update cf2 set r1 = null where p1 = 'foo';").discard_result();
}).then([&e] {
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{utf8_type->decompose(sstring("foo")), { }}
});
});
}).then([&e] {
forward_jump_clocks(600s);
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r1) values ('foo', 'bar') using ttl 500;").discard_result();
}).then([&e] {
return e.execute_cql("insert into cf2 (p1, r2) values ('foo', null);").discard_result();
}).then([&e] {
forward_jump_clocks(600s);
return e.execute_cql("select p1, r1 from cf2 where p1 = 'foo';").then([] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{utf8_type->decompose(sstring("foo")), { }}
});
});
});
});
}
SEASTAR_TEST_CASE(test_types) {
return do_with_cql_env([] (cql_test_env& e) {
return make_ready_future<>().then([&e] {
return e.execute_cql(
"CREATE TABLE all_types ("
" a ascii PRIMARY KEY,"
" b bigint,"
" c blob,"
" d boolean,"
" e double,"
" f float,"
" g inet,"
" h int,"
" i text,"
" j timestamp,"
" k timeuuid,"
" l uuid,"
" m varchar,"
" n varint,"
" o decimal,"
" p tinyint,"
" q smallint,"
" r date,"
" s time,"
" u duration,"
");").discard_result();
}).then([&e] {
e.require_table_exists("ks", "all_types");
return e.execute_cql(
"INSERT INTO all_types (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, u) VALUES ("
" 'ascii',"
" 123456789,"
" 0xdeadbeef,"
" true,"
" 3.14,"
" 3.14,"
" '127.0.0.1',"
" 3,"
" 'zażółć gęślą jaźń',"
" '2001-10-18 14:15:55.134+0000',"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" 'varchar',"
" 123,"
" 1.23,"
" 3,"
" 3,"
" '1970-01-02',"
" '00:00:00.000000001',"
" 1y2mo3w4d5h6m7s8ms9us10ns"
");").discard_result();
}).then([&e] {
return e.execute_cql("SELECT * FROM all_types WHERE a = 'ascii'");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
struct tm t = { 0 };
t.tm_year = 2001 - 1900;
t.tm_mon = 10 - 1;
t.tm_mday = 18;
t.tm_hour = 14;
t.tm_min = 15;
t.tm_sec = 55;
auto tp = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(134);
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii")), long_type->decompose(123456789l),
from_hex("deadbeef"), boolean_type->decompose(true),
double_type->decompose(3.14), float_type->decompose(3.14f),
inet_addr_type->decompose(net::inet_address("127.0.0.1")),
int32_type->decompose(3), utf8_type->decompose(sstring("zażółć gęślą jaźń")),
timestamp_type->decompose(tp),
timeuuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
uuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
utf8_type->decompose(sstring("varchar")), varint_type->decompose(boost::multiprecision::cpp_int(123)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(123) }),
byte_type->decompose(int8_t(3)),
short_type->decompose(int16_t(3)),
simple_date_type->decompose(int32_t(0x80000001)),
time_type->decompose(int64_t(0x0000000000000001)),
duration_type->decompose(cql_duration("1y2mo3w4d5h6m7s8ms9us10ns"))
}
});
return e.execute_cql(
"INSERT INTO all_types (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, u) VALUES ("
" blobAsAscii(asciiAsBlob('ascii2')),"
" blobAsBigint(bigintAsBlob(123456789)),"
" bigintAsBlob(12),"
" blobAsBoolean(booleanAsBlob(true)),"
" blobAsDouble(doubleAsBlob(3.14)),"
" blobAsFloat(floatAsBlob(3.14)),"
" blobAsInet(inetAsBlob('127.0.0.1')),"
" blobAsInt(intAsBlob(3)),"
" blobAsText(textAsBlob('zażółć gęślą jaźń')),"
" blobAsTimestamp(timestampAsBlob('2001-10-18 14:15:55.134+0000')),"
" blobAsTimeuuid(timeuuidAsBlob(d2177dd0-eaa2-11de-a572-001b779c76e3)),"
" blobAsUuid(uuidAsBlob(d2177dd0-eaa2-11de-a572-001b779c76e3)),"
" blobAsVarchar(varcharAsBlob('varchar')), blobAsVarint(varintAsBlob(123)),"
" blobAsDecimal(decimalAsBlob(1.23)),"
" blobAsTinyint(tinyintAsBlob(3)),"
" blobAsSmallint(smallintAsBlob(3)),"
" blobAsDate(dateAsBlob('1970-01-02')),"
" blobAsTime(timeAsBlob('00:00:00.000000001')),"
" blobAsDuration(durationAsBlob(10y9mo8w7d6h5m4s3ms2us1ns))"
");").discard_result();
}).then([&e] {
return e.execute_cql("SELECT * FROM all_types WHERE a = 'ascii2'");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
struct tm t = {0};
t.tm_year = 2001 - 1900;
t.tm_mon = 10 - 1;
t.tm_mday = 18;
t.tm_hour = 14;
t.tm_min = 15;
t.tm_sec = 55;
auto tp = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(134);
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii2")), long_type->decompose(123456789l),
from_hex("000000000000000c"), boolean_type->decompose(true),
double_type->decompose(3.14), float_type->decompose(3.14f),
inet_addr_type->decompose(net::inet_address("127.0.0.1")),
int32_type->decompose(3), utf8_type->decompose(sstring("zażółć gęślą jaźń")),
timestamp_type->decompose(tp),
timeuuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
uuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
utf8_type->decompose(sstring("varchar")), varint_type->decompose(boost::multiprecision::cpp_int(123)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(123) }),
byte_type->decompose(int8_t(3)),
short_type->decompose(int16_t(3)),
simple_date_type->decompose(int32_t(0x80000001)),
time_type->decompose(int64_t(0x0000000000000001)),
duration_type->decompose(cql_duration("10y9mo8w7d6h5m4s3ms2us1ns"))
}
});
});
});
}
SEASTAR_TEST_CASE(test_order_by) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table torder (p1 int, c1 int, c2 int, r1 int, r2 int, PRIMARY KEY(p1, c1, c2));").discard_result().then([&e] {
e.require_table_exists("ks", "torder");
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 2, 1, 0);").discard_result();
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
});
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 1, 1, 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (0, 2, 2, 5);").discard_result();
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
});
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (1, 1, 0, 6);").discard_result();
}).then([&e] {
return e.execute_cql("insert into torder (p1, c1, c2, r1) values (1, 2, 3, 7);").discard_result();
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(7)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
{int32_type->decompose(1), int32_type->decompose(0), int32_type->decompose(6)},
});
}).then([&e] {
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 asc, c2 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(0), int32_type->decompose(6)},
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(7)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) and c1 < 2 order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) and c1 >= 2 order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(7)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 in (0, 1) order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(0), int32_type->decompose(6)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 > 1 order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 desc, c2 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 desc, c2 desc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 > 1 order by c1 asc, c2 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 asc, c2 asc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
{int32_type->decompose(2), int32_type->decompose(2), int32_type->decompose(5)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 and c1 >= 2 order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2), int32_type->decompose(1), int32_type->decompose(0)},
});
return e.execute_cql("select c1, c2, r1 from torder where p1 = 0 order by c1 asc, c2 asc limit 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1), int32_type->decompose(1), int32_type->decompose(4)},
});
});
});
}
SEASTAR_TEST_CASE(test_order_by_validate) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table torderv (p1 int, c1 int, c2 int, r1 int, r2 int, PRIMARY KEY(p1, c1, c2));").discard_result().then([&e] {
return e.execute_cql("select c2, r1 from torderv where p1 = 0 order by c desc;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("select c2, r1 from torderv where p1 = 0 order by c2 desc;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("select c2, r1 from torderv where p1 = 0 order by c1 desc, c2 asc;");
}).then_wrapped([&e] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
return e.execute_cql("select c2, r1 from torderv order by c1 asc;");
}).then_wrapped([] (future<shared_ptr<cql_transport::messages::result_message>> f) {
assert_that_failed(f);
});
});
}
SEASTAR_TEST_CASE(test_multi_column_restrictions) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tmcr (p1 int, c1 int, c2 int, c3 int, r1 int, PRIMARY KEY (p1, c1, c2, c3));").discard_result().then([&e] {
e.require_table_exists("ks", "tmcr");
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 0, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 1, 0, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 0, 1, 1, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 0, 0, 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 0, 1, 5);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 1, 0, 6);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tmcr (p1, c1, c2, c3, r1) values (0, 1, 1, 1, 7);").discard_result();
}).then([&e] {
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) = (0, 1, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2) = (0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) in ((0, 1, 0), (1, 0, 1), (0, 1, 0));");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(5)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2) in ((0, 1), (1, 0), (0, 1));");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(3)},
{int32_type->decompose(4)},
{int32_type->decompose(5)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) >= (1, 0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(5)},
{int32_type->decompose(6)},
{int32_type->decompose(7)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) >= (0, 1, 1) and (c1, c2, c3) < (1, 1, 0);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
{int32_type->decompose(4)},
{int32_type->decompose(5)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2) >= (0, 1) and (c1, c2, c3) < (1, 0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(2)},
{int32_type->decompose(3)},
{int32_type->decompose(4)},
});
return e.execute_cql("select r1 from tmcr where p1 = 0 and (c1, c2, c3) > (0, 1, 0) and (c1, c2) <= (0, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
});
});
});
}
SEASTAR_TEST_CASE(test_select_distinct) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tsd (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
e.require_table_exists("ks", "tsd");
return e.execute_cql("insert into tsd (p1, c1, r1) values (0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (1, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (1, 1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (2, 2, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd (p1, c1, r1) values (2, 3, 3);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1 from tsd;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0)})
.with_row({int32_type->decompose(1)})
.with_row({int32_type->decompose(2)});
return e.execute_cql("select distinct p1 from tsd limit 3;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0)})
.with_row({int32_type->decompose(1)})
.with_row({int32_type->decompose(2)});
return e.execute_cql("create table tsd2 (p1 int, p2 int, c1 int, r1 int, PRIMARY KEY ((p1, p2), c1));").discard_result();
}).then([&e] {
e.require_table_exists("ks", "tsd2");
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (0, 0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (0, 0, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (1, 1, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (1, 1, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (2, 2, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd2 (p1, p2, c1, r1) values (2, 2, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1, p2 from tsd2;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0), int32_type->decompose(0)})
.with_row({int32_type->decompose(1), int32_type->decompose(1)})
.with_row({int32_type->decompose(2), int32_type->decompose(2)});
return e.execute_cql("select distinct p1, p2 from tsd2 limit 3;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0), int32_type->decompose(0)})
.with_row({int32_type->decompose(1), int32_type->decompose(1)})
.with_row({int32_type->decompose(2), int32_type->decompose(2)});
return e.execute_cql("create table tsd3 (p1 int, r1 int, PRIMARY KEY (p1));").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd3 (p1, r1) values (2, 2);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1 from tsd3;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0)})
.with_row({int32_type->decompose(1)})
.with_row({int32_type->decompose(2)});
return e.execute_cql("create table tsd4 (p1 int, c1 int, s1 int static, r1 int, PRIMARY KEY (p1, c1));").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, c1, s1, r1) values (0, 0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, c1, r1) values (0, 1, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, s1) values (2, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tsd4 (p1, s1) values (3, 2);").discard_result();
}).then([&e] {
return e.execute_cql("select distinct p1, s1 from tsd4;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(3)
.with_row({int32_type->decompose(0), int32_type->decompose(0)})
.with_row({int32_type->decompose(2), int32_type->decompose(1)})
.with_row({int32_type->decompose(3), int32_type->decompose(2)});
});
});
}
SEASTAR_TEST_CASE(test_select_distinct_with_where_clause) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE cf (k int, a int, b int, PRIMARY KEY (k, a))").get();
for (int i = 0; i < 10; i++) {
e.execute_cql(sprint("INSERT INTO cf (k, a, b) VALUES (%d, %d, %d)", i, i, i)).get();
e.execute_cql(sprint("INSERT INTO cf (k, a, b) VALUES (%d, %d, %d)", i, i * 10, i * 10)).get();
}
BOOST_REQUIRE_THROW(e.execute_cql("SELECT DISTINCT k FROM cf WHERE a >= 80 ALLOW FILTERING").get(), std::exception);
BOOST_REQUIRE_THROW(e.execute_cql("SELECT DISTINCT k FROM cf WHERE k IN (1, 2, 3) AND a = 10").get(), std::exception);
BOOST_REQUIRE_THROW(e.execute_cql("SELECT DISTINCT k FROM cf WHERE b = 5").get(), std::exception);
assert_that(e.execute_cql("SELECT DISTINCT k FROM cf WHERE k = 1").get0())
.is_rows().with_size(1)
.with_row({int32_type->decompose(1)});
assert_that(e.execute_cql("SELECT DISTINCT k FROM cf WHERE k IN (5, 6, 7)").get0())
.is_rows().with_size(3)
.with_row({int32_type->decompose(5)})
.with_row({int32_type->decompose(6)})
.with_row({int32_type->decompose(7)});
// static columns
e.execute_cql("CREATE TABLE cf2 (k int, a int, s int static, b int, PRIMARY KEY (k, a))").get();
for (int i = 0; i < 10; i++) {
e.execute_cql(sprint("INSERT INTO cf2 (k, a, b, s) VALUES (%d, %d, %d, %d)", i, i, i, i)).get();
e.execute_cql(sprint("INSERT INTO cf2 (k, a, b, s) VALUES (%d, %d, %d, %d)", i, i * 10, i * 10, i * 10)).get();
}
assert_that(e.execute_cql("SELECT DISTINCT s FROM cf2 WHERE k = 5").get0())
.is_rows().with_size(1)
.with_row({int32_type->decompose(50)});
assert_that(e.execute_cql("SELECT DISTINCT s FROM cf2 WHERE k IN (5, 6, 7)").get0())
.is_rows().with_size(3)
.with_row({int32_type->decompose(50)})
.with_row({int32_type->decompose(60)})
.with_row({int32_type->decompose(70)});
});
});
}
SEASTAR_TEST_CASE(test_batch_insert_statement) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table cf (p1 varchar, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
return e.execute_cql(R"(BEGIN BATCH
insert into cf (p1, c1, r1) values ('key1', 1, 100);
insert into cf (p1, c1, r1) values ('key2', 2, 200);
APPLY BATCH;)"
).discard_result();
}).then([&e] {
return e.execute_cql(R"(BEGIN BATCH
update cf set r1 = 66 where p1 = 'key1' and c1 = 1;
update cf set r1 = 33 where p1 = 'key2' and c1 = 2;
APPLY BATCH;)"
).discard_result();
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key1")}, {1}, "r1", 66);
}).then([&e] {
return e.require_column_has_value("cf", {sstring("key2")}, {2}, "r1", 33);
});
});
}
SEASTAR_TEST_CASE(test_in_restriction) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tir (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1));").discard_result().then([&e] {
e.require_table_exists("ks", "tir");
return e.execute_cql("insert into tir (p1, c1, r1) values (0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (1, 0, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (1, 1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir (p1, c1, r1) values (2, 3, 4);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tir where p1 in ();");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(0);
return e.execute_cql("select r1 from tir where p1 in (2, 0, 2, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows_ignore_order({
{int32_type->decompose(4)},
{int32_type->decompose(0)},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tir where p1 = 1 and c1 in ();");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_size(0);
return e.execute_cql("select r1 from tir where p1 = 1 and c1 in (2, 0, 2, 1);");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
return e.execute_cql("select r1 from tir where p1 = 1 and c1 in (2, 0, 2, 1) order by c1 desc;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{int32_type->decompose(3)},
{int32_type->decompose(2)},
{int32_type->decompose(1)},
});
return e.prepare("select r1 from tir where p1 in ?");
}).then([&e] (cql3::prepared_cache_key_type prepared_id){
auto my_list_type = list_type_impl::get_instance(int32_type, true);
std::vector<cql3::raw_value> raw_values;
auto in_values_list = my_list_type->decompose(make_list_value(my_list_type,
list_type_impl::native_type{{int(2), int(0), int(2), int(1)}}));
raw_values.emplace_back(cql3::raw_value::make_value(in_values_list));
return e.execute_prepared(prepared_id,raw_values);
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows_ignore_order({
{int32_type->decompose(4)},
{int32_type->decompose(0)},
{int32_type->decompose(1)},
{int32_type->decompose(2)},
{int32_type->decompose(3)},
});
}).then([&e]{
return e.execute_cql("create table tir2 (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1,r1));").discard_result();
}).then([&e] {
e.require_table_exists("ks", "tir2");
return e.execute_cql("insert into tir2 (p1, c1, r1) values (0, 0, 0);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (1, 0, 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (1, 1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (1, 2, 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tir2 (p1, c1, r1) values (2, 3, 4);").discard_result();
}).then([&e]{
return e.execute_cql("select r1 from tir2 where (c1,r1) in ((0, 1),(1,2),(0,1),(1,2),(3,3));");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows_ignore_order({
{int32_type->decompose(1)},
{int32_type->decompose(2)},
});
});
});
}
SEASTAR_TEST_CASE(test_compact_storage) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tcs (p1 int, c1 int, r1 int, PRIMARY KEY (p1, c1)) with compact storage;").discard_result().then([&e] {
return e.require_table_exists("ks", "tcs");
}).then([&e] {
return e.execute_cql("insert into tcs (p1, c1, r1) values (1, 2, 3);").discard_result();
}).then([&e] {
return e.require_column_has_value("tcs", {1}, {2}, "r1", 3);
}).then([&e] {
return e.execute_cql("update tcs set r1 = 4 where p1 = 1 and c1 = 2;").discard_result();
}).then([&e] {
return e.require_column_has_value("tcs", {1}, {2}, "r1", 4);
}).then([&e] {
return e.execute_cql("select * from tcs where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(4) },
});
return e.execute_cql("create table tcs2 (p1 int, c1 int, PRIMARY KEY (p1, c1)) with compact storage;").discard_result();
}).then([&e] {
return e.require_table_exists("ks", "tcs2");
}).then([&e] {
return e.execute_cql("insert into tcs2 (p1, c1) values (1, 2);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs2 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2) },
});
return e.execute_cql("create table tcs3 (p1 int, c1 int, c2 int, r1 int, PRIMARY KEY (p1, c1, c2)) with compact storage;").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, c2, r1) values (1, 2, 3, 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, r1) values (1, 2, 5);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, r1) values (1, 3, 6);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, c2, r1) values (1, 3, 5, 7);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs3 (p1, c1, c2, r1) values (1, 3, blobasint(0x), 8);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), {}, int32_type->decompose(5) },
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4) },
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
{ int32_type->decompose(1), int32_type->decompose(3), bytes(), int32_type->decompose(8) },
{ int32_type->decompose(1), int32_type->decompose(3), int32_type->decompose(5), int32_type->decompose(7) },
});
return e.execute_cql("delete from tcs3 where p1 = 1 and c1 = 2;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
{ int32_type->decompose(1), int32_type->decompose(3), bytes(), int32_type->decompose(8) },
{ int32_type->decompose(1), int32_type->decompose(3), int32_type->decompose(5), int32_type->decompose(7) },
});
return e.execute_cql("delete from tcs3 where p1 = 1 and c1 = 3 and c2 = 5;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
{ int32_type->decompose(1), int32_type->decompose(3), bytes(), int32_type->decompose(8) },
});
return e.execute_cql("delete from tcs3 where p1 = 1 and c1 = 3 and c2 = blobasint(0x);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs3 where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(3), {}, int32_type->decompose(6) },
});
return e.execute_cql("create table tcs4 (p1 int PRIMARY KEY, c1 int, c2 int) with compact storage;").discard_result();
}).then([&e] {
return e.execute_cql("insert into tcs4 (p1) values (1);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tcs4;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({ });
});
});
}
SEASTAR_TEST_CASE(test_collections_of_collections) {
return do_with_cql_env([] (cql_test_env& e) {
auto set_of_ints = set_type_impl::get_instance(int32_type, true);
auto set_of_sets = set_type_impl::get_instance(set_of_ints, true);
auto map_of_sets = map_type_impl::get_instance(set_of_ints, int32_type, true);
return e.execute_cql("create table cf_sos (p1 int PRIMARY KEY, v set<frozen<set<int>>>);").discard_result().then([&e] {
return e.execute_cql("insert into cf_sos (p1, v) values (1, {{1, 2}, {3, 4}, {5, 6}});").discard_result();
}).then([&e, set_of_sets, set_of_ints] {
return e.require_column_has_value("cf_sos", {1}, {},
"v", make_set_value(set_of_sets, set_type_impl::native_type({
make_set_value(set_of_ints, set_type_impl::native_type({1, 2})),
make_set_value(set_of_ints, set_type_impl::native_type({3, 4})),
make_set_value(set_of_ints, set_type_impl::native_type({5, 6})),
})));
}).then([&e, set_of_sets, set_of_ints] {
return e.execute_cql("delete v[{3, 4}] from cf_sos where p1 = 1;").discard_result();
}).then([&e, set_of_sets, set_of_ints] {
return e.require_column_has_value("cf_sos", {1}, {},
"v", make_set_value(set_of_sets, set_type_impl::native_type({
make_set_value(set_of_ints, set_type_impl::native_type({1, 2})),
make_set_value(set_of_ints, set_type_impl::native_type({5, 6})),
})));
}).then([&e, set_of_sets, set_of_ints] {
return e.execute_cql("update cf_sos set v = v - {{1, 2}, {5}} where p1 = 1;").discard_result();
}).then([&e, set_of_sets, set_of_ints] {
return e.require_column_has_value("cf_sos", {1}, {},
"v", make_set_value(set_of_sets, set_type_impl::native_type({
make_set_value(set_of_ints, set_type_impl::native_type({5, 6})),
})));
}).then([&e] {
return e.execute_cql("create table cf_mos (p1 int PRIMARY KEY, v map<frozen<set<int>>, int>);").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.execute_cql("insert into cf_mos (p1, v) values (1, {{1, 2}: 7, {3, 4}: 8, {5, 6}: 9});").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.require_column_has_value("cf_mos", {1}, {},
"v", make_map_value(map_of_sets, map_type_impl::native_type({
{ make_set_value(set_of_ints, set_type_impl::native_type({1, 2})), 7 },
{ make_set_value(set_of_ints, set_type_impl::native_type({3, 4})), 8 },
{ make_set_value(set_of_ints, set_type_impl::native_type({5, 6})), 9 },
})));
}).then([&e, map_of_sets, set_of_ints] {
return e.execute_cql("delete v[{3, 4}] from cf_mos where p1 = 1;").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.require_column_has_value("cf_mos", {1}, {},
"v", make_map_value(map_of_sets, map_type_impl::native_type({
{ make_set_value(set_of_ints, set_type_impl::native_type({1, 2})), 7 },
{ make_set_value(set_of_ints, set_type_impl::native_type({5, 6})), 9 },
})));
}).then([&e, map_of_sets, set_of_ints] {
return e.execute_cql("update cf_mos set v = v - {{1, 2}, {5}} where p1 = 1;").discard_result();
}).then([&e, map_of_sets, set_of_ints] {
return e.require_column_has_value("cf_mos", {1}, {},
"v", make_map_value(map_of_sets, map_type_impl::native_type({
{ make_set_value(set_of_ints, set_type_impl::native_type({5, 6})), 9 },
})));
});
});
}
SEASTAR_TEST_CASE(test_result_order) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tro (p1 int, c1 text, r1 int, PRIMARY KEY (p1, c1)) with compact storage;").discard_result().then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'z', 1);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'bbbb', 2);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'a', 3);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'aaa', 4);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'bb', 5);").discard_result();
}).then([&e] {
return e.execute_cql("insert into tro (p1, c1, r1) values (1, 'cccc', 6);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tro where p1 = 1;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), utf8_type->decompose(sstring("a")), int32_type->decompose(3) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("aaa")), int32_type->decompose(4) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("bb")), int32_type->decompose(5) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("bbbb")), int32_type->decompose(2) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("cccc")), int32_type->decompose(6) },
{ int32_type->decompose(1), utf8_type->decompose(sstring("z")), int32_type->decompose(1) },
});
});
});
}
SEASTAR_TEST_CASE(test_frozen_collections) {
return do_with_cql_env([] (cql_test_env& e) {
auto set_of_ints = set_type_impl::get_instance(int32_type, false);
auto list_of_ints = list_type_impl::get_instance(int32_type, false);
auto frozen_map_of_set_and_list = map_type_impl::get_instance(set_of_ints, list_of_ints, false);
return e.execute_cql("CREATE TABLE tfc (a int, b int, c frozen<map<set<int>, list<int>>> static, d int, PRIMARY KEY (a, b));").discard_result().then([&e] {
return e.execute_cql("INSERT INTO tfc (a, b, c, d) VALUES (0, 0, {}, 0);").discard_result();
}).then([&e] {
return e.execute_cql("SELECT * FROM tfc;");
}).then([&e, frozen_map_of_set_and_list] (shared_ptr<cql_transport::messages::result_message> msg) {
map_type_impl::mutation_view empty_mv{};
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(0), int32_type->decompose(0), frozen_map_of_set_and_list->to_value(empty_mv, cql_serialization_format::internal()), int32_type->decompose(0) },
});
});
});
}
SEASTAR_TEST_CASE(test_alter_table) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tat (pk1 int, c1 int, ck2 int, r1 int, r2 int, PRIMARY KEY (pk1, c1, ck2));").discard_result().then([&e] {
return e.execute_cql("insert into tat (pk1, c1, ck2, r1, r2) values (1, 2, 3, 4, 5);").discard_result();
}).then([&e] {
return e.execute_cql("alter table tat with comment = 'This is a comment.';").discard_result();
}).then([&e] {
BOOST_REQUIRE_EQUAL(e.local_db().find_schema("ks", "tat")->comment(), sstring("This is a comment."));
return e.execute_cql("alter table tat alter r2 type blob;").discard_result();
}).then([&e] {
return e.execute_cql("select pk1, c1, ck2, r1, r2 from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), int32_type->decompose(5) },
});
}).then([&e] {
return e.execute_cql("insert into tat (pk1, c1, ck2, r2) values (1, 2, 3, 0x1234567812345678);").discard_result();
}).then([&e] {
return e.execute_cql("select pk1, c1, ck2, r1, r2 from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), from_hex("1234567812345678") },
});
}).then([&e] {
return e.execute_cql("alter table tat rename pk1 to p1 and ck2 to c2;").discard_result();
}).then([&e] {
return e.execute_cql("select p1, c1, c2, r1, r2 from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat add r1_2 int;").discard_result();
}).then([&e] {
return e.execute_cql("insert into tat (p1, c1, c2, r1_2) values (1, 2, 3, 6);").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(4), int32_type->decompose(6), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat drop r1;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), int32_type->decompose(6), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat add r1 int;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), {}, int32_type->decompose(6), from_hex("1234567812345678") },
});
return e.execute_cql("alter table tat drop r2;").discard_result();
}).then([&e] {
return e.execute_cql("alter table tat add r2 int;").discard_result();
}).then([&e] {
return e.execute_cql("select * from tat;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ int32_type->decompose(1), int32_type->decompose(2), int32_type->decompose(3), {}, int32_type->decompose(6), {} },
});
});
});
}
SEASTAR_TEST_CASE(test_map_query) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE xx (k int PRIMARY KEY, m map<text, int>);").get();
e.execute_cql("insert into xx (k, m) values (0, {'v2': 1});").get();
auto m_type = map_type_impl::get_instance(utf8_type, int32_type, true);
assert_that(e.execute_cql("select m from xx where k = 0;").get0())
.is_rows().with_rows({
{ make_map_value(m_type, map_type_impl::native_type({{sstring("v2"), 1}})).serialize() }
});
e.execute_cql("delete m['v2'] from xx where k = 0;").get();
assert_that(e.execute_cql("select m from xx where k = 0;").get0())
.is_rows().with_rows({{{}}});
});
});
}
SEASTAR_TEST_CASE(test_drop_table) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("create table tmp (pk int, v int, PRIMARY KEY (pk));").get();
e.execute_cql("drop columnfamily tmp;").get();
e.execute_cql("create table tmp (pk int, v int, PRIMARY KEY (pk));").get();
e.execute_cql("drop columnfamily tmp;").get();
});
});
}
SEASTAR_TEST_CASE(test_reversed_slice_with_empty_range_before_all_rows) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE test (a int, b int, c int, s1 int static, s2 int static, PRIMARY KEY (a, b));").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 0, 0, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 1, 1, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 2, 2, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 3, 3, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 4, 4, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 5, 5, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 6, 6, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 7, 7, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 8, 8, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 9, 9, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 10, 10, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 11, 11, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 12, 12, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 13, 13, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 14, 14, 17, 42);").get();
e.execute_cql("INSERT INTO test (a, b, c, s1, s2) VALUES (99, 15, 15, 17, 42);").get();
assert_that(e.execute_cql("select * from test WHERE a = 99 and b < 0 ORDER BY b DESC limit 2;").get0())
.is_rows().is_empty();
assert_that(e.execute_cql("select * from test WHERE a = 99 order by b desc;").get0())
.is_rows().with_size(16);
assert_that(e.execute_cql("select * from test;").get0())
.is_rows().with_size(16);
});
});
}
SEASTAR_TEST_CASE(test_query_with_range_tombstones) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
e.execute_cql("CREATE TABLE test (pk int, ck int, v int, PRIMARY KEY (pk, ck));").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 0, 0);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 2, 2);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 4, 4);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 5, 5);").get();
e.execute_cql("INSERT INTO test (pk, ck, v) VALUES (0, 6, 6);").get();
e.execute_cql("DELETE FROM test WHERE pk = 0 AND ck >= 1 AND ck <= 3;").get();
e.execute_cql("DELETE FROM test WHERE pk = 0 AND ck > 4 AND ck <= 8;").get();
e.execute_cql("DELETE FROM test WHERE pk = 0 AND ck > 0 AND ck <= 1;").get();
assert_that(e.execute_cql("SELECT v FROM test WHERE pk = 0 ORDER BY ck DESC;").get0())
.is_rows()
.with_rows({
{ int32_type->decompose(4) },
{ int32_type->decompose(0) },
});
assert_that(e.execute_cql("SELECT v FROM test WHERE pk = 0;").get0())
.is_rows()
.with_rows({
{ int32_type->decompose(0) },
{ int32_type->decompose(4) },
});
});
});
}
SEASTAR_TEST_CASE(test_alter_table_validation) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table tatv (p1 int, c1 int, c2 int, r1 int, r2 set<int>, PRIMARY KEY (p1, c1, c2));").discard_result().then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv drop r2;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r2 list<int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r2 set<text>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r2 set<int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv rename r2 to r3;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv alter r1 type bigint;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv alter r2 type map<int, int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r3 map<int, int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r4 set<text>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv drop r3;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv drop r4;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r3 map<int, text>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r4 set<int>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("alter table tatv add r3 map<int, blob>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
return e.execute_cql("alter table tatv add r4 set<blob>;").discard_result();
}).then_wrapped([&e] (future<> f) {
assert(!f.failed());
});
});
}
SEASTAR_TEST_CASE(test_pg_style_string_literal) {
return do_with_cql_env([] (cql_test_env& e) {
return e.execute_cql("create table test (p1 text, PRIMARY KEY (p1));").discard_result().then([&e] {
return e.execute_cql("insert into test (p1) values ($$Apostrophe's$ $ not$ $ '' escaped$$);").discard_result();
}).then([&e] {
return e.execute_cql("insert into test (p1) values ($$$''valid$_$key$$);").discard_result();
}).then([&e] {
return e.execute_cql("insert into test (p1) values ('$normal$valid$$$$key$');").discard_result();
}).then([&e] {
return e.execute_cql("insert into test (p1) values ($ $invalid$$);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("insert into test (p1) values ($$invalid$ $);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("insert into test (p1) values ($ $invalid$$$);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("insert into test (p1) values ($$ \n\n$invalid);").discard_result();
}).then_wrapped([&e] (future<> f) {
assert_that_failed(f);
return e.execute_cql("select * from test;");
}).then([&e] (shared_ptr<cql_transport::messages::result_message> msg) {
assert_that(msg).is_rows().with_rows({
{ utf8_type->decompose(sstring("Apostrophe's$ $ not$ $ '' escaped")) },
{ utf8_type->decompose(sstring("$''valid$_$key")) },
{ utf8_type->decompose(sstring("$normal$valid$$$$key$")) },
});
});
});
}
SEASTAR_TEST_CASE(test_insert_large_collection_values) {
return do_with_cql_env([] (cql_test_env& e) {
return seastar::async([&e] {
auto map_type = map_type_impl::get_instance(utf8_type, utf8_type, true);
auto set_type = set_type_impl::get_instance(utf8_type, true);
auto list_type = list_type_impl::get_instance(utf8_type, true);
e.create_table([map_type, set_type, list_type] (sstring ks_name) {
// CQL: CREATE TABLE tbl (pk text PRIMARY KEY, m map<text, text>, s set<text>, l list<text>);
return schema({}, ks_name, "tbl",
{{"pk", utf8_type}},
{},
{
{"m", map_type},
{"s", set_type},
{"l", list_type}
},
{},
utf8_type);
}).get();
sstring long_value(std::numeric_limits<uint16_t>::max() + 10, 'x');
e.execute_cql(sprint("INSERT INTO tbl (pk, l) VALUES ('Zamyatin', ['%s']);", long_value)).get();
assert_that(e.execute_cql("SELECT l FROM tbl WHERE pk ='Zamyatin';").get0())
.is_rows().with_rows({
{ make_list_value(list_type, list_type_impl::native_type({{long_value}})).serialize() }
});
BOOST_REQUIRE_THROW(e.execute_cql(sprint("INSERT INTO tbl (pk, s) VALUES ('Orwell', {'%s'});", long_value)).get(), std::exception);
e.execute_cql(sprint("INSERT INTO tbl (pk, m) VALUES ('Haksli', {'key': '%s'});", long_value)).get();
assert_that(e.execute_cql("SELECT m FROM tbl WHERE pk ='Haksli';").get0())
.is_rows().with_rows({
{ make_map_value(map_type, map_type_impl::native_type({{sstring("key"), long_value}})).serialize() }
});
BOOST_REQUIRE_THROW(e.execute_cql(sprint("INSERT INTO tbl (pk, m) VALUES ('Golding', {'%s': 'value'});", long_value)).get(), std::exception);
auto make_query_options = [] (cql_protocol_version_type version) {
return std::make_unique<cql3::query_options>(db::consistency_level::ONE, infinite_timeout_config, std::experimental::nullopt,
std::vector<cql3::raw_value_view>(), false,
cql3::query_options::specific_options::DEFAULT, cql_serialization_format{version});
};
BOOST_REQUIRE_THROW(e.execute_cql("SELECT l FROM tbl WHERE pk = 'Zamyatin';", make_query_options(2)).get(), std::exception);
BOOST_REQUIRE_THROW(e.execute_cql("SELECT m FROM tbl WHERE pk = 'Haksli';", make_query_options(2)).get(), std::exception);
});
});
}
SEASTAR_TEST_CASE(test_select_json_types) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE all_types ("
" a ascii PRIMARY KEY,"
" b bigint,"
" c blob,"
" d boolean,"
" e double,"
" f float,"
" \"G\" inet," // note - case-sensitive column names
" \"H\" int,"
" \"I\" text,"
" j timestamp,"
" k timeuuid,"
" l uuid,"
" m varchar,"
" n varint,"
" o decimal,"
" p tinyint,"
" q smallint,"
" r date,"
" s time,"
" u duration,"
" w int,"
");").get();
e.require_table_exists("ks", "all_types").get();
e.execute_cql(
"INSERT INTO all_types (a, b, c, d, e, f, \"G\", \"H\", \"I\", j, k, l, m, n, o, p, q, r, s, u) VALUES ("
" 'ascii',"
" 123456789,"
" 0xdeadbeef,"
" true,"
" 3.14,"
" 3.14,"
" '127.0.0.1',"
" 3,"
" 'zażółć gęślą jaźń',"
" '2001-10-18 14:15:55.134+0000',"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" d2177dd0-eaa2-11de-a572-001b779c76e3,"
" 'varchar',"
" 123,"
" 1.23,"
" 3,"
" 3,"
" '1970-01-02',"
" '00:00:00.000000001',"
" 1y2mo3w4d5h6m7s8ms9us10ns"
");").get();
auto msg = e.execute_cql("SELECT JSON a, b, c, d, e, f, \"G\", \"H\", \"I\", j, k, l, m, n, o, p, q, r, s, u, w, unixtimestampof(k) FROM all_types WHERE a = 'ascii'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"ascii\", "
"\"b\": 123456789, "
"\"c\": \"0xdeadbeef\", "
"\"d\": true, "
"\"e\": 3.14, "
"\"f\": 3.14, "
"\"\\\"G\\\"\": \"127.0.0.1\", " // note the double quoting on case-sensitive column names
"\"\\\"H\\\"\": 3, "
"\"\\\"I\\\"\": \"zażółć gęślą jaźń\", "
"\"j\": \"2001-10-18T14:15:55.134000\", "
"\"k\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"l\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"m\": \"varchar\", "
"\"n\": 123, "
"\"o\": 1.23, "
"\"p\": 3, "
"\"q\": 3, "
"\"r\": \"1970-01-02\", "
"\"s\": 00:00:00.000000001, "
"\"u\": \"1y2mo25d5h6m7s8ms9us10ns\", "
"\"w\": null, "
"\"unixtimestampof(k)\": 1261009589805}"
)
}
});
msg = e.execute_cql("SELECT toJson(a), toJson(b), toJson(c), toJson(d), toJson(e), toJson(f),"
"toJson(\"G\"), toJson(\"H\"), toJson(\"I\"), toJson(j), toJson(k), toJson(l), toJson(m), toJson(n),"
"toJson(o), toJson(p), toJson(q), toJson(r), toJson(s), toJson(u), toJson(w),"
"toJson(unixtimestampof(k)), toJson(toJson(toJson(p))) FROM all_types WHERE a = 'ascii'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose("\"ascii\""),
utf8_type->decompose("123456789"),
utf8_type->decompose("\"0xdeadbeef\""),
utf8_type->decompose("true"),
utf8_type->decompose("3.14"),
utf8_type->decompose("3.14"),
utf8_type->decompose("\"127.0.0.1\""),
utf8_type->decompose("3"),
utf8_type->decompose("\"zażółć gęślą jaźń\""),
utf8_type->decompose("\"2001-10-18T14:15:55.134000\""),
utf8_type->decompose("\"d2177dd0-eaa2-11de-a572-001b779c76e3\""),
utf8_type->decompose("\"d2177dd0-eaa2-11de-a572-001b779c76e3\""),
utf8_type->decompose("\"varchar\""),
utf8_type->decompose("123"),
utf8_type->decompose("1.23"),
utf8_type->decompose("3"),
utf8_type->decompose("3"),
utf8_type->decompose("\"1970-01-02\""),
utf8_type->decompose("00:00:00.000000001"),
utf8_type->decompose("\"1y2mo25d5h6m7s8ms9us10ns\""),
utf8_type->decompose("null"),
utf8_type->decompose("1261009589805"),
utf8_type->decompose("\"\\\"3\\\"\"")
}
});
});
}
SEASTAR_TEST_CASE(test_select_json_collections) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE collections ("
" a text PRIMARY KEY,"
" b map<int, text>,"
" c set<float>,"
" d list<frozen<list<tinyint>>>"
");").get();
e.require_table_exists("ks", "collections").get();
e.execute_cql(
"INSERT INTO collections (a, b, c, d) VALUES ("
" 'key',"
" { 1 : 'abc', 3 : 'de', 2 : '!' },"
" { 0.0, 4.5, 2.25, 1.125, NAN, INFINITY },"
" [[ 3 , 1, 4, 1, 5, 9 ], [ ], [ 1, 1, 2 ]]"
");").get();
auto msg = e.execute_cql("SELECT JSON * FROM collections WHERE a = 'key'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"key\", "
"\"b\": {\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}, "
"\"c\": [0, 1.125, 2.25, 4.5, null, null], " // note - one null is for NAN, one for INFINITY
"\"d\": [[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]}"
)
}
});
msg = e.execute_cql("SELECT toJson(a), toJson(b), toJson(c), toJson(d) FROM collections WHERE a = 'key'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose("\"key\""),
utf8_type->decompose("{\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}"),
utf8_type->decompose("[0, 1.125, 2.25, 4.5, null, null]"),
utf8_type->decompose("[[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]"),
}
});
try {
e.execute_cql("SELECT toJson(a, b) FROM collections WHERE a = 'key'").get();
BOOST_FAIL("should've thrown");
} catch (...) {}
try {
e.execute_cql("SELECT toJson() FROM collections WHERE a = 'key'").get();
BOOST_FAIL("should've thrown");
} catch (...) {}
});
}
SEASTAR_TEST_CASE(test_insert_json_types) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE all_types ("
" a ascii PRIMARY KEY,"
" b bigint,"
" c blob,"
" d boolean,"
" e double,"
" f float,"
" \"G\" inet,"
" \"H\" int,"
" \"I\" text,"
" j timestamp,"
" k timeuuid,"
" l uuid,"
" m varchar,"
" n varint,"
" o decimal,"
" p tinyint,"
" q smallint,"
" r date,"
" s time,"
" u duration,"
");").get();
e.require_table_exists("ks", "all_types").get();
e.execute_cql(
"INSERT INTO all_types JSON '"
"{\"a\": \"ascii\", "
"\"b\": 123456789, "
"\"c\": \"0xdeadbeef\", "
"\"d\": true, "
"\"e\": 3.14, "
"\"f\": \"3.14\", "
"\"\\\"G\\\"\": \"127.0.0.1\", "
"\"\\\"H\\\"\": 3, "
"\"\\\"I\\\"\": \"zażółć gęślą jaźń\", "
"\"j\": \"2001-10-18T14:15:55.134+0000\", "
"\"k\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"l\": \"d2177dd0-eaa2-11de-a572-001b779c76e3\", "
"\"m\": \"varchar\", "
"\"n\": 123, "
"\"o\": 1.23, "
"\"p\": \"3\", "
"\"q\": 3, "
"\"r\": \"1970-01-02\", "
"\"s\": \"00:00:00.000000001\", "
"\"u\": \"1y2mo25d5h6m7s8ms9us10ns\"}"
"'").get();
auto msg = e.execute_cql("SELECT * FROM all_types WHERE a = 'ascii'").get0();
struct tm t = { 0 };
t.tm_year = 2001 - 1900;
t.tm_mon = 10 - 1;
t.tm_mday = 18;
t.tm_hour = 14;
t.tm_min = 15;
t.tm_sec = 55;
auto tp = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(134);
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii")),
inet_addr_type->decompose(net::inet_address("127.0.0.1")), // note - case-sensitive columns go right after the key
int32_type->decompose(3), utf8_type->decompose(sstring("zażółć gęślą jaźń")),
long_type->decompose(123456789l),
from_hex("deadbeef"), boolean_type->decompose(true),
double_type->decompose(3.14), float_type->decompose(3.14f),
timestamp_type->decompose(tp),
timeuuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
uuid_type->decompose(utils::UUID(sstring("d2177dd0-eaa2-11de-a572-001b779c76e3"))),
utf8_type->decompose(sstring("varchar")), varint_type->decompose(boost::multiprecision::cpp_int(123)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(123) }),
byte_type->decompose(int8_t(3)),
short_type->decompose(int16_t(3)),
simple_date_type->decompose(int32_t(0x80000001)),
time_type->decompose(int64_t(0x0000000000000001)),
duration_type->decompose(cql_duration("1y2mo3w4d5h6m7s8ms9us10ns"))
}
});
e.execute_cql("UPDATE all_types SET b = fromJson('42') WHERE a = fromJson('\"ascii\"');").get();
e.execute_cql("UPDATE all_types SET \"I\" = fromJson('\"zażółć gęślą jaźń\"') WHERE a = fromJson('\"ascii\"');").get();
e.execute_cql("UPDATE all_types SET n = fromJson('\"2147483648\"') WHERE a = fromJson('\"ascii\"');").get();
e.execute_cql("UPDATE all_types SET o = fromJson('\"3.45\"') WHERE a = fromJson('\"ascii\"');").get();
msg = e.execute_cql("SELECT a, b, \"I\", n, o FROM all_types WHERE a = 'ascii'").get0();
assert_that(msg).is_rows().with_rows({
{
ascii_type->decompose(sstring("ascii")),
long_type->decompose(42l),
utf8_type->decompose(sstring("zażółć gęślą jaźń")),
varint_type->decompose(boost::multiprecision::cpp_int(2147483648)),
decimal_type->decompose(big_decimal { 2, boost::multiprecision::cpp_int(345) }),
}
});
e.execute_cql("CREATE TABLE multi_column_pk_table (p1 int, p2 int, p3 int, c1 int, c2 int, v int, PRIMARY KEY((p1, p2, p3), c1, c2));").get();
e.require_table_exists("ks", "multi_column_pk_table").get();
e.execute_cql("INSERT INTO multi_column_pk_table JSON '"
"{\"p1\": 1, "
"\"p2\": 2, "
"\"p3\": 3, "
"\"c1\": 4, "
"\"c2\": 5, "
"\"v\": 6 "
"}'").get();
msg = e.execute_cql("SELECT * FROM multi_column_pk_table").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5),
int32_type->decompose(6)
}
});
});
}
SEASTAR_TEST_CASE(test_insert_json_collections) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql(
"CREATE TABLE collections ("
" a text PRIMARY KEY,"
" b map<int, text>,"
" c set<float>,"
" d list<frozen<list<tinyint>>>"
");").get();
e.require_table_exists("ks", "collections").get();
e.execute_cql(
"INSERT INTO collections JSON '"
"{\"a\": \"key\", "
"\"b\": {\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}, "
"\"c\": [0, 1.125, 2.25, 4.5], "
"\"d\": [[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]}"
"'").get();
auto msg = e.execute_cql("SELECT JSON * FROM collections WHERE a = 'key'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"key\", "
"\"b\": {\"1\": \"abc\", \"2\": \"!\", \"3\": \"de\"}, "
"\"c\": [0, 1.125, 2.25, 4.5], "
"\"d\": [[3, 1, 4, 1, 5, 9], [], [1, 1, 2]]}"
)
}
});
e.execute_cql("INSERT INTO collections JSON '{\"a\": \"key2\"}'").get();
msg = e.execute_cql("SELECT JSON * FROM collections WHERE a = 'key2'").get0();
assert_that(msg).is_rows().with_rows({
{
utf8_type->decompose(
"{\"a\": \"key2\", "
"\"b\": null, "
"\"c\": null, "
"\"d\": null}"
)
}
});
});
}
SEASTAR_TEST_CASE(test_prepared_json) {
return do_with_cql_env_thread([] (cql_test_env& e) {
auto prepared = e.execute_cql(
"CREATE TABLE json_data ("
" a text PRIMARY KEY,"
" b map<int, text>,"
" c decimal,"
" d list<float>"
");").get();
e.require_table_exists("ks", "json_data").get();
cql3::prepared_cache_key_type prepared_id = e.prepare(
"begin batch \n"
" insert into json_data json :named_bound0; \n"
" insert into json_data json ?; \n"
" insert into json_data json :named_bound1; \n"
" insert into json_data json ?; \n"
"apply batch;").get0();
std::vector<cql3::raw_value> raw_values;
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a1\", \"b\": {\"3\": \"three\", \"6\": \"six\", \"0\": \"zero\"}, \"c\": 1.23, \"d\": [1.25, 3.75, 2.5]}")));
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a2\", \"b\": {\"6\": \"six\", \"0\": \"zero\"}, \"c\": 1.23, \"d\": [3.75, 2.5]}")));
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a3\", \"b\": {\"3\": \"three\", \"0\": \"zero\"}, \"c\": 1.23, \"d\": [1.25, 2.5]}")));
raw_values.emplace_back(cql3::raw_value::make_value(utf8_type->decompose(
"{\"a\": \"a4\", \"b\": {\"1\": \"one\"}, \"c\": 1.23, \"d\": [1]}")));
e.execute_prepared(prepared_id, raw_values).get();
auto msg = e.execute_cql("select json * from json_data where a='a1'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a1\", \"b\": {\"0\": \"zero\", \"3\": \"three\", \"6\": \"six\"}, \"c\": 1.23, \"d\": [1.25, 3.75, 2.5]}")
}});
msg = e.execute_cql("select json * from json_data where a='a2'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a2\", \"b\": {\"0\": \"zero\", \"6\": \"six\"}, \"c\": 1.23, \"d\": [3.75, 2.5]}")
}});
msg = e.execute_cql("select json * from json_data where a='a3'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a3\", \"b\": {\"0\": \"zero\", \"3\": \"three\"}, \"c\": 1.23, \"d\": [1.25, 2.5]}")
}});
msg = e.execute_cql("select json * from json_data where a='a4'").get0();
assert_that(msg).is_rows().with_rows({{
utf8_type->decompose(
"{\"a\": \"a4\", \"b\": {\"1\": \"one\"}, \"c\": 1.23, \"d\": [1]}")
}});
});
}
SEASTAR_TEST_CASE(test_long_text_value) {
return do_with_cql_env_thread([] (cql_test_env& e) {
auto prepared = e.execute_cql("CREATE TABLE t (id int PRIMARY KEY, v text, v2 varchar)").get();
e.require_table_exists("ks", "t").get();
sstring big_one(17324, 'x');
sstring bigger_one(29123, 'y');
e.execute_cql(sprint("INSERT INTO t (id, v, v2) values (1, '%s', '%s')", big_one, big_one)).get();
e.execute_cql(sprint("INSERT INTO t (id, v, v2) values (2, '%s', '%s')", bigger_one, bigger_one)).get();
auto msg = e.execute_cql("select v, v2 from t where id = 1").get0();
assert_that(msg).is_rows().with_rows({{utf8_type->decompose(big_one), utf8_type->decompose(big_one)}});
msg = e.execute_cql("select v, v2 from t where id = 2").get0();
assert_that(msg).is_rows().with_rows({{utf8_type->decompose(bigger_one), utf8_type->decompose(bigger_one)}});
});
}
SEASTAR_TEST_CASE(test_time_conversions) {
return do_with_cql_env_thread([] (cql_test_env& e) {
auto prepared = e.execute_cql(
"CREATE TABLE time_data (id timeuuid PRIMARY KEY, d date, ts timestamp);").get();
e.require_table_exists("ks", "time_data").get();
e.execute_cql("INSERT INTO time_data (id, d, ts) VALUES (f4e30f80-6958-11e8-96d6-000000000000, '2017-06-11', '2018-06-05 00:00:00+0000');").get();
struct tm t = { 0 };
t.tm_year = 2018 - 1900;
t.tm_mon = 6 - 1;
t.tm_mday = 6;
t.tm_hour = 7;
t.tm_min = 12;
t.tm_sec = 22;
auto tp1 = db_clock::from_time_t(timegm(&t)) + std::chrono::milliseconds(136);
t.tm_year = 2017 - 1900;
t.tm_mday = 11;
t.tm_hour = 0;
t.tm_min = 0;
t.tm_sec = 0;
auto tp2 = db_clock::from_time_t(timegm(&t));
auto msg = e.execute_cql("select todate(id), todate(ts), totimestamp(id), totimestamp(d), tounixtimestamp(id),"
"tounixtimestamp(ts), tounixtimestamp(d), tounixtimestamp(totimestamp(todate(totimestamp(todate(id))))) from time_data;").get0();
assert_that(msg).is_rows().with_rows({{
simple_date_type->decompose(int32_t(0x80004518)),
simple_date_type->decompose(int32_t(0x80004517)),
timestamp_type->decompose(tp1),
timestamp_type->decompose(tp2),
long_type->decompose(int64_t(1528269142136)),
long_type->decompose(int64_t(1528156800000)),
long_type->decompose(int64_t(1497139200000)),
long_type->decompose(int64_t(1528243200000))
}});
});
}
// Corner-case test that checks for the paging code's preparedness for an empty
// range list.
SEASTAR_TEST_CASE(test_empty_partition_range_scan) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("create keyspace empty_partition_range_scan with replication = {'class': 'SimpleStrategy', 'replication_factor': 1};").get();
e.execute_cql("create table empty_partition_range_scan.tb (a int, b int, c int, val int, PRIMARY KEY ((a,b),c) );").get();
auto qo = std::make_unique<cql3::query_options>(db::consistency_level::LOCAL_ONE, infinite_timeout_config, std::vector<cql3::raw_value>{},
cql3::query_options::specific_options{1, nullptr, {}, api::new_timestamp()});
auto res = e.execute_cql("select * from empty_partition_range_scan.tb where token (a,b) > 1 and token(a,b) <= 1;", std::move(qo)).get0();
assert_that(res).is_rows().is_empty();
});
}
SEASTAR_TEST_CASE(test_allow_filtering_check) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (p int, c int, v int, PRIMARY KEY(p, c));").get();
e.require_table_exists("ks", "t").get();
for (int i = 0; i < 3; ++i) {
for (int j = 0; j <3; ++j) {
e.execute_cql(sprint("INSERT INTO t(p, c, v) VALUES (%s, %s, %s)", i, j, j)).get();
}
}
std::vector<sstring> queries = {
"SELECT * FROM t WHERE p = 1",
"SELECT * FROM t WHERE p = 1 and c > 2",
"SELECT * FROM t WHERE p = 1 and c = 2"
};
for (const sstring& q : queries) {
e.execute_cql(q).get();
e.execute_cql(q + " ALLOW FILTERING").get();
}
queries = {
"SELECT * FROM t WHERE c = 2",
"SELECT * FROM t WHERE c <= 4"
};
for (const sstring& q : queries) {
BOOST_CHECK_THROW(e.execute_cql(q).get(), exceptions::invalid_request_exception);
e.execute_cql(q + " ALLOW FILTERING").get();
}
e.execute_cql("CREATE TABLE t2 (p int PRIMARY KEY, a int, b int);").get();
e.require_table_exists("ks", "t2").get();
e.execute_cql("CREATE INDEX ON t2(a)").get();
for (int i = 0; i < 5; ++i) {
e.execute_cql(sprint("INSERT INTO t2 (p, a, b) VALUES (%s, %s, %s)", i, i * 10, i * 100)).get();
}
queries = {
"SELECT * FROM t2 WHERE p = 1",
"SELECT * FROM t2 WHERE a = 20"
};
for (const sstring& q : queries) {
e.execute_cql(q).get();
e.execute_cql(q + " ALLOW FILTERING").get();
}
queries = {
"SELECT * FROM t2 WHERE a = 20 AND b = 200"
};
for (const sstring& q : queries) {
BOOST_CHECK_THROW(e.execute_cql(q).get(), exceptions::invalid_request_exception);
e.execute_cql(q + " ALLOW FILTERING").get();
}
});
}
SEASTAR_TEST_CASE(test_allow_filtering_pk_ck) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, PRIMARY KEY ((a, b), c, d));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (11, 12, 13, 14, 15)").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (11, 15, 16, 17, 18)").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (21, 22, 23, 24, 25)").get();
e.execute_cql("INSERT INTO t (a,b,c,d,e) VALUES (31, 32, 33, 34, 35)").get();
auto msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c = 16").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 12 AND c > 13 AND d = 14").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c = 16").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c > 13 AND d >= 17 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 12 AND c > 13 AND d > 17").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT * FROM t WHERE a = 11 AND b = 15 AND c > 13 AND d >= 17 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a <= 11 AND c > 15 AND d >= 16 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a <= 11 AND b >= 15 AND c > 15 AND d >= 16 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
}});
msg = e.execute_cql("SELECT * FROM t WHERE a <= 100 AND b >= 15 AND c > 0 AND d <= 100 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(11),
int32_type->decompose(15),
int32_type->decompose(16),
int32_type->decompose(17),
int32_type->decompose(18),
},
{
int32_type->decompose(31),
int32_type->decompose(32),
int32_type->decompose(33),
int32_type->decompose(34),
int32_type->decompose(35),
},
{
int32_type->decompose(21),
int32_type->decompose(22),
int32_type->decompose(23),
int32_type->decompose(24),
int32_type->decompose(25),
}
});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE a <= 11 AND c > 15 AND d >= 16").get(), exceptions::invalid_request_exception);
});
}
SEASTAR_TEST_CASE(test_allow_filtering_clustering_column) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (k int, c int, v int, PRIMARY KEY (k, c));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (k, c, v) VALUES (1, 2, 1)").get();
e.execute_cql("INSERT INTO t (k, c, v) VALUES (1, 3, 2)").get();
e.execute_cql("INSERT INTO t (k, c, v) VALUES (2, 2, 3)").get();
auto msg = e.execute_cql("SELECT * FROM t WHERE k = 1").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
},
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2)
}
});
msg = e.execute_cql("SELECT * FROM t WHERE k = 1 AND c > 2").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2)
}});
msg = e.execute_cql("SELECT * FROM t WHERE k = 1 AND c = 2").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c = 2").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c > 2 AND c <= 4").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT * FROM t WHERE c = 2 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
},
{
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(3)
}
});
msg = e.execute_cql("SELECT * FROM t WHERE c > 2 AND c <= 4 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2)
}});
});
}
SEASTAR_TEST_CASE(test_allow_filtering_static_column) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, s int static, PRIMARY KEY(a, b));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("CREATE INDEX ON t(c)").get();
e.execute_cql("INSERT INTO t (a, b, c, s) VALUES (1, 1, 1, 1)").get();
e.execute_cql("INSERT INTO t (a, b, c) VALUES (1, 2, 1)").get();
e.execute_cql("INSERT INTO t (a, s) VALUES (3, 3)").get();
e.execute_cql("INSERT INTO t (a, b, c, s) VALUES (2, 1, 1, 2)").get();
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t WHERE c = 1 AND s = 2 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1)
}});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t WHERE c = 1 AND s = 1 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1)
},
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(1)
}
});
});
});
}
SEASTAR_TEST_CASE(test_allow_filtering_multiple_regular) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, f list<int>, g set<int>, PRIMARY KEY(a, b));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 1, 1, 1, 1, [1], {})").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 2, 3, 4, 5, [1, 2], {1, 2, 3})").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 3, 5, 1, 9, [1, 2, 3], {1, 2})").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e, f, g) VALUES (1, 4, 5, 7, 5, [], {1})").get();
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c = 5").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE d = 1").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE e = 5").get(), exceptions::invalid_request_exception);
// Collection filtering queries are not supported yet
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE f contains 2").get(), exceptions::invalid_request_exception);
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE g contains 1").get(), exceptions::invalid_request_exception);
auto msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 3 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
}});
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE e >= 5 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
},
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
},
{
int32_type->decompose(1),
int32_type->decompose(4),
int32_type->decompose(5),
int32_type->decompose(7),
int32_type->decompose(5)
}
});
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 5 and e = 9 and d = 1 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}});
cql3::prepared_cache_key_type prepared_id = e.prepare("SELECT a, b, c, d, e FROM t WHERE a = ? and d = ? ALLOW FILTERING").get0();
std::vector<cql3::raw_value> raw_values {
cql3::raw_value::make_value(int32_type->decompose(1)),
cql3::raw_value::make_value(int32_type->decompose(1))
};
msg = e.execute_prepared(prepared_id, raw_values).get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1)
},
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}
});
prepared_id = e.prepare("SELECT a, b, c, d, e FROM t WHERE a = ? and d = ? ALLOW FILTERING").get0();
raw_values[1] = cql3::raw_value::make_value(int32_type->decompose(9));
msg = e.execute_prepared(prepared_id, raw_values).get0();
assert_that(msg).is_rows().with_size(0);
});
}
SEASTAR_TEST_CASE(test_allow_filtering_desc) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, PRIMARY KEY((a, b), c, d)) WITH CLUSTERING ORDER BY (c DESC);").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 2, 1, 1, 1)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 2, 3, 4, 5)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 2, 5, 1, 9)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 2, 6, 7, 5)").get();
auto msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c > 3 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(6),
int32_type->decompose(7),
int32_type->decompose(5)
},
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}
});
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c < 4 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
},
{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1)
}
});
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 4 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_size(0);
});
}
SEASTAR_TEST_CASE(test_allow_filtering_with_secondary_index) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int, b int, c int, d int, e int, PRIMARY KEY(a, b));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("CREATE INDEX ON t(c)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 1, 1, 1, 1)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 2, 3, 4, 5)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 3, 5, 1, 9)").get();
e.execute_cql("INSERT INTO t (a, b, c, d, e) VALUES (1, 4, 5, 7, 5)").get();
auto msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 3").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(4),
int32_type->decompose(5)
}});
BOOST_CHECK_THROW(e.execute_cql("SELECT * FROM t WHERE c = 5 and d = 1").get(), exceptions::invalid_request_exception);
msg = e.execute_cql("SELECT a, b, c, d, e FROM t WHERE c = 5 and d = 1 ALLOW FILTERING").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(5),
int32_type->decompose(1),
int32_type->decompose(9)
}});
e.execute_cql("CREATE TABLE t2 (pk1 int, pk2 int, c1 int, c2 int, v int, PRIMARY KEY ((pk1, pk2), c1, c2));").get();
e.execute_cql("CREATE INDEX ON t2(v)").get();
for (int i = 1; i <= 5; ++i) {
for (int j = 1; j <= 2; ++j) {
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, 1, 1, 1, i)).get();
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, 1, 1, i, i)).get();
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, 1, i, i, i)).get();
e.execute_cql(sprint("INSERT INTO t2 (pk1, pk2, c1, c2, v) VALUES (%s, %s, %s, %s, %s)", j, i, i, i, i)).get();
}
}
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c1 > 0 AND c1 < 5 AND c2 = 1 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c1 > 0 AND c1 < 5 AND c2 = 3 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3)
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
}
});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c2 > 1 AND c2 < 5 AND v = 1 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND c1 > 1 AND c2 > 2 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
}
});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 = 1 AND pk2 > 1 AND c2 > 2 AND v = 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3),
int32_type->decompose(3)
}});
});
eventually([&] {
auto msg = e.execute_cql("SELECT * FROM t2 WHERE pk1 >= 2 AND pk2 <=3 AND c1 IN(0,1,2) AND c2 IN(0,1,2) AND v < 3 ALLOW FILTERING;").get0();
assert_that(msg).is_rows().with_rows({
{
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2)
},
{
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(2)
},
{
int32_type->decompose(2),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(2)
}
});
});
});
}
SEASTAR_TEST_CASE(test_in_restriction_on_not_last_partition_key) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (a int,b int,c int,d int,PRIMARY KEY ((a, b), c));").get();
e.require_table_exists("ks", "t").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,1,1,100); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,1,2,200); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,1,3,300); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,2,1,300); ").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,3,1,1300);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (1,3,2,1400);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,3,2,1400);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,1,2,1400);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,1,3,1300);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (2,2,3,1300);").get();
e.execute_cql("INSERT INTO t (a,b,c,d) VALUES (3,1,3,1300);").get();
{
auto msg = e.execute_cql("SELECT * FROM t WHERE a IN (1,2) AND b IN (2,3) AND c>=2 AND c<=3;").get0();
assert_that(msg).is_rows().with_rows_ignore_order({
{
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(2),
int32_type->decompose(1400),
},
{
int32_type->decompose(2),
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(1300),
},
{
int32_type->decompose(2),
int32_type->decompose(3),
int32_type->decompose(2),
int32_type->decompose(1400),
}
});
}
{
auto msg = e.execute_cql("SELECT * FROM t WHERE a IN (1,3) AND b=1 AND c>=2 AND c<=3;").get0();
assert_that(msg).is_rows().with_rows_ignore_order({
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(2),
int32_type->decompose(200),
},
{
int32_type->decompose(1),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(300),
},
{
int32_type->decompose(3),
int32_type->decompose(1),
int32_type->decompose(3),
int32_type->decompose(1300),
}
});
}
});
}
SEASTAR_TEST_CASE(test_static_multi_cell_static_lists_with_ckey) {
return do_with_cql_env_thread([] (cql_test_env& e) {
e.execute_cql("CREATE TABLE t (p int, c int, slist list<int> static, v int, PRIMARY KEY (p, c));").get();
e.execute_cql("INSERT INTO t (p, c, slist, v) VALUES (1, 1, [1], 1); ").get();
{
e.execute_cql("UPDATE t SET slist[0] = 3, v = 3 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({{3}}))) },
{ int32_type->decompose(3) }
});
}
{
e.execute_cql("UPDATE t SET slist = [4], v = 4 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({{4}}))) },
{ int32_type->decompose(4) }
});
}
{
e.execute_cql("UPDATE t SET slist = [3] + slist , v = 5 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3, 4}))) },
{ int32_type->decompose(5) }
});
}
{
e.execute_cql("UPDATE t SET slist = slist + [5] , v = 6 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3, 4, 5}))) },
{ int32_type->decompose(6) }
});
}
{
e.execute_cql("DELETE slist[2] from t WHERE p = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3, 4}))) },
{ int32_type->decompose(6) }
});
}
{
e.execute_cql("UPDATE t SET slist = slist - [4] , v = 7 WHERE p = 1 AND c = 1;").get();
auto msg = e.execute_cql("SELECT slist, v FROM t WHERE p = 1 AND c = 1;").get0();
auto slist_type = list_type_impl::get_instance(int32_type, true);
assert_that(msg).is_rows().with_row({
{ slist_type->decompose(make_list_value(slist_type, list_type_impl::native_type({3}))) },
{ int32_type->decompose(7) }
});
}
});
}
|
/***************************************************************************
copyright : (C) 2002 - 2008 by Scott Wheeler
email : wheeler@kde.org
***************************************************************************/
/***************************************************************************
* This library is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License version *
* 2.1 as published by the Free Software Foundation. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA *
* 02110-1301 USA *
* *
* Alternatively, this file is available under the Mozilla Public *
* License Version 1.1. You may obtain a copy of the License at *
* http://www.mozilla.org/MPL/ *
***************************************************************************/
#include <tdebug.h>
#include <tzlib.h>
#include "id3v2framefactory.h"
#include "id3v2synchdata.h"
#include "id3v1genres.h"
#include "frames/attachedpictureframe.h"
#include "frames/commentsframe.h"
#include "frames/relativevolumeframe.h"
#include "frames/textidentificationframe.h"
#include "frames/uniquefileidentifierframe.h"
#include "frames/unknownframe.h"
#include "frames/generalencapsulatedobjectframe.h"
#include "frames/urllinkframe.h"
#include "frames/unsynchronizedlyricsframe.h"
#include "frames/popularimeterframe.h"
#include "frames/privateframe.h"
#include "frames/ownershipframe.h"
#include "frames/synchronizedlyricsframe.h"
#include "frames/eventtimingcodesframe.h"
#include "frames/chapterframe.h"
#include "frames/tableofcontentsframe.h"
#include "frames/podcastframe.h"
using namespace TagLib;
using namespace ID3v2;
namespace
{
void updateGenre(TextIdentificationFrame *frame)
{
StringList fields = frame->fieldList();
StringList newfields;
for(StringList::ConstIterator it = fields.begin(); it != fields.end(); ++it) {
String s = *it;
int end = s.find(")");
if(s.startsWith("(") && end > 0) {
// "(12)Genre"
String text = s.substr(end + 1);
bool ok;
int number = s.substr(1, end - 1).toInt(&ok);
if(ok && number >= 0 && number <= 255 && !(ID3v1::genre(number) == text))
newfields.append(s.substr(1, end - 1));
if(!text.isEmpty())
newfields.append(text);
}
else {
// "Genre" or "12"
newfields.append(s);
}
}
if(newfields.isEmpty())
fields.append(String());
frame->setText(newfields);
}
}
class FrameFactory::FrameFactoryPrivate
{
public:
FrameFactoryPrivate() :
defaultEncoding(String::Latin1),
useDefaultEncoding(false) {}
String::Type defaultEncoding;
bool useDefaultEncoding;
template <class T> void setTextEncoding(T *frame)
{
if(useDefaultEncoding)
frame->setTextEncoding(defaultEncoding);
}
};
FrameFactory FrameFactory::factory;
////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////
FrameFactory *FrameFactory::instance()
{
return &factory;
}
Frame *FrameFactory::createFrame(const ByteVector &data, bool synchSafeInts) const
{
return createFrame(data, static_cast<unsigned int>(synchSafeInts ? 4 : 3));
}
Frame *FrameFactory::createFrame(const ByteVector &data, unsigned int version) const
{
Header tagHeader;
tagHeader.setMajorVersion(version);
return createFrame(data, &tagHeader);
}
Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader) const
{
ByteVector data = origData;
unsigned int version = tagHeader->majorVersion();
Frame::Header *header = new Frame::Header(data, version);
ByteVector frameID = header->frameID();
// A quick sanity check -- make sure that the frameID is 4 uppercase Latin1
// characters. Also make sure that there is data in the frame.
if(frameID.size() != (version < 3 ? 3 : 4) ||
header->frameSize() <= static_cast<unsigned int>(header->dataLengthIndicator() ? 4 : 0) ||
header->frameSize() > data.size())
{
delete header;
return 0;
}
#ifndef NO_ITUNES_HACKS
if(version == 3 && frameID.size() == 4 && frameID[3] == '\0') {
// iTunes v2.3 tags store v2.2 frames - convert now
frameID = frameID.mid(0, 3);
header->setFrameID(frameID);
header->setVersion(2);
updateFrame(header);
header->setVersion(3);
}
#endif
for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) {
if( (*it < 'A' || *it > 'Z') && (*it < '0' || *it > '9') ) {
delete header;
return 0;
}
}
if(version > 3 && (tagHeader->unsynchronisation() || header->unsynchronisation())) {
// Data lengths are not part of the encoded data, but since they are synch-safe
// integers they will be never actually encoded.
ByteVector frameData = data.mid(Frame::Header::size(version), header->frameSize());
frameData = SynchData::decode(frameData);
data = data.mid(0, Frame::Header::size(version)) + frameData;
}
// TagLib doesn't mess with encrypted frames, so just treat them
// as unknown frames.
if(!zlib::isAvailable() && header->compression()) {
debug("Compressed frames are currently not supported.");
return new UnknownFrame(data, header);
}
if(header->encryption()) {
debug("Encrypted frames are currently not supported.");
return new UnknownFrame(data, header);
}
if(!updateFrame(header)) {
header->setTagAlterPreservation(true);
return new UnknownFrame(data, header);
}
// updateFrame() might have updated the frame ID.
frameID = header->frameID();
// This is where things get necissarily nasty. Here we determine which
// Frame subclass (or if none is found simply an Frame) based
// on the frame ID. Since there are a lot of possibilities, that means
// a lot of if blocks.
// Text Identification (frames 4.2)
// Apple proprietary WFED (Podcast URL), MVNM (Movement Name), MVIN (Movement Number) are in fact text frames.
if(frameID.startsWith("T") || frameID == "WFED" || frameID == "MVNM" || frameID == "MVIN") {
TextIdentificationFrame *f = frameID != "TXXX"
? new TextIdentificationFrame(data, header)
: new UserTextIdentificationFrame(data, header);
d->setTextEncoding(f);
if(frameID == "TCON")
updateGenre(f);
return f;
}
// Comments (frames 4.10)
if(frameID == "COMM") {
CommentsFrame *f = new CommentsFrame(data, header);
d->setTextEncoding(f);
return f;
}
// Attached Picture (frames 4.14)
if(frameID == "APIC") {
AttachedPictureFrame *f = new AttachedPictureFrame(data, header);
d->setTextEncoding(f);
return f;
}
// ID3v2.2 Attached Picture
if(frameID == "PIC") {
AttachedPictureFrame *f = new AttachedPictureFrameV22(data, header);
d->setTextEncoding(f);
return f;
}
// Relative Volume Adjustment (frames 4.11)
if(frameID == "RVA2")
return new RelativeVolumeFrame(data, header);
// Unique File Identifier (frames 4.1)
if(frameID == "UFID")
return new UniqueFileIdentifierFrame(data, header);
// General Encapsulated Object (frames 4.15)
if(frameID == "GEOB") {
GeneralEncapsulatedObjectFrame *f = new GeneralEncapsulatedObjectFrame(data, header);
d->setTextEncoding(f);
return f;
}
// URL link (frames 4.3)
if(frameID.startsWith("W")) {
if(frameID != "WXXX") {
return new UrlLinkFrame(data, header);
}
else {
UserUrlLinkFrame *f = new UserUrlLinkFrame(data, header);
d->setTextEncoding(f);
return f;
}
}
// Unsynchronized lyric/text transcription (frames 4.8)
if(frameID == "USLT") {
UnsynchronizedLyricsFrame *f = new UnsynchronizedLyricsFrame(data, header);
if(d->useDefaultEncoding)
f->setTextEncoding(d->defaultEncoding);
return f;
}
// Synchronised lyrics/text (frames 4.9)
if(frameID == "SYLT") {
SynchronizedLyricsFrame *f = new SynchronizedLyricsFrame(data, header);
if(d->useDefaultEncoding)
f->setTextEncoding(d->defaultEncoding);
return f;
}
// Event timing codes (frames 4.5)
if(frameID == "ETCO")
return new EventTimingCodesFrame(data, header);
// Popularimeter (frames 4.17)
if(frameID == "POPM")
return new PopularimeterFrame(data, header);
// Private (frames 4.27)
if(frameID == "PRIV")
return new PrivateFrame(data, header);
// Ownership (frames 4.22)
if(frameID == "OWNE") {
OwnershipFrame *f = new OwnershipFrame(data, header);
d->setTextEncoding(f);
return f;
}
// Chapter (ID3v2 chapters 1.0)
if(frameID == "CHAP")
return new ChapterFrame(tagHeader, data, header);
// Table of contents (ID3v2 chapters 1.0)
if(frameID == "CTOC")
return new TableOfContentsFrame(tagHeader, data, header);
// Apple proprietary PCST (Podcast)
if(frameID == "PCST")
return new PodcastFrame(data, header);
return new UnknownFrame(data, header);
}
void FrameFactory::rebuildAggregateFrames(ID3v2::Tag *tag) const
{
if(tag->header()->majorVersion() < 4 &&
tag->frameList("TDRC").size() == 1 &&
tag->frameList("TDAT").size() == 1)
{
TextIdentificationFrame *tdrc =
static_cast<TextIdentificationFrame *>(tag->frameList("TDRC").front());
UnknownFrame *tdat = static_cast<UnknownFrame *>(tag->frameList("TDAT").front());
if(tdrc->fieldList().size() == 1 &&
tdrc->fieldList().front().size() == 4 &&
tdat->data().size() >= 5)
{
String date(tdat->data().mid(1), String::Type(tdat->data()[0]));
if(date.length() == 4) {
tdrc->setText(tdrc->toString() + '-' + date.substr(2, 2) + '-' + date.substr(0, 2));
if(tag->frameList("TIME").size() == 1) {
UnknownFrame *timeframe = static_cast<UnknownFrame *>(tag->frameList("TIME").front());
if(timeframe->data().size() >= 5) {
String time(timeframe->data().mid(1), String::Type(timeframe->data()[0]));
if(time.length() == 4) {
tdrc->setText(tdrc->toString() + 'T' + time.substr(0, 2) + ':' + time.substr(2, 2));
}
}
}
}
}
}
}
String::Type FrameFactory::defaultTextEncoding() const
{
return d->defaultEncoding;
}
void FrameFactory::setDefaultTextEncoding(String::Type encoding)
{
d->useDefaultEncoding = true;
d->defaultEncoding = encoding;
}
////////////////////////////////////////////////////////////////////////////////
// protected members
////////////////////////////////////////////////////////////////////////////////
FrameFactory::FrameFactory() :
d(new FrameFactoryPrivate())
{
}
FrameFactory::~FrameFactory()
{
delete d;
}
namespace
{
// Frame conversion table ID3v2.2 -> 2.4
const char *frameConversion2[][2] = {
{ "BUF", "RBUF" },
{ "CNT", "PCNT" },
{ "COM", "COMM" },
{ "CRA", "AENC" },
{ "ETC", "ETCO" },
{ "GEO", "GEOB" },
{ "IPL", "TIPL" },
{ "MCI", "MCDI" },
{ "MLL", "MLLT" },
{ "POP", "POPM" },
{ "REV", "RVRB" },
{ "SLT", "SYLT" },
{ "STC", "SYTC" },
{ "TAL", "TALB" },
{ "TBP", "TBPM" },
{ "TCM", "TCOM" },
{ "TCO", "TCON" },
{ "TCP", "TCMP" },
{ "TCR", "TCOP" },
{ "TDY", "TDLY" },
{ "TEN", "TENC" },
{ "TFT", "TFLT" },
{ "TKE", "TKEY" },
{ "TLA", "TLAN" },
{ "TLE", "TLEN" },
{ "TMT", "TMED" },
{ "TOA", "TOAL" },
{ "TOF", "TOFN" },
{ "TOL", "TOLY" },
{ "TOR", "TDOR" },
{ "TOT", "TOAL" },
{ "TP1", "TPE1" },
{ "TP2", "TPE2" },
{ "TP3", "TPE3" },
{ "TP4", "TPE4" },
{ "TPA", "TPOS" },
{ "TPB", "TPUB" },
{ "TRC", "TSRC" },
{ "TRD", "TDRC" },
{ "TRK", "TRCK" },
{ "TS2", "TSO2" },
{ "TSA", "TSOA" },
{ "TSC", "TSOC" },
{ "TSP", "TSOP" },
{ "TSS", "TSSE" },
{ "TST", "TSOT" },
{ "TT1", "TIT1" },
{ "TT2", "TIT2" },
{ "TT3", "TIT3" },
{ "TXT", "TOLY" },
{ "TXX", "TXXX" },
{ "TYE", "TDRC" },
{ "UFI", "UFID" },
{ "ULT", "USLT" },
{ "WAF", "WOAF" },
{ "WAR", "WOAR" },
{ "WAS", "WOAS" },
{ "WCM", "WCOM" },
{ "WCP", "WCOP" },
{ "WPB", "WPUB" },
{ "WXX", "WXXX" },
// Apple iTunes nonstandard frames
{ "PCS", "PCST" },
{ "TCT", "TCAT" },
{ "TDR", "TDRL" },
{ "TDS", "TDES" },
{ "TID", "TGID" },
{ "WFD", "WFED" },
{ "MVN", "MVNM" },
{ "MVI", "MVIN" },
};
const size_t frameConversion2Size = sizeof(frameConversion2) / sizeof(frameConversion2[0]);
// Frame conversion table ID3v2.3 -> 2.4
const char *frameConversion3[][2] = {
{ "TORY", "TDOR" },
{ "TYER", "TDRC" },
{ "IPLS", "TIPL" },
};
const size_t frameConversion3Size = sizeof(frameConversion3) / sizeof(frameConversion3[0]);
}
bool FrameFactory::updateFrame(Frame::Header *header) const
{
const ByteVector frameID = header->frameID();
switch(header->version()) {
case 2: // ID3v2.2
{
if(frameID == "CRM" ||
frameID == "EQU" ||
frameID == "LNK" ||
frameID == "RVA" ||
frameID == "TIM" ||
frameID == "TSI" ||
frameID == "TDA")
{
debug("ID3v2.4 no longer supports the frame type " + String(frameID) +
". It will be discarded from the tag.");
return false;
}
// ID3v2.2 only used 3 bytes for the frame ID, so we need to convert all of
// the frames to their 4 byte ID3v2.4 equivalent.
for(size_t i = 0; i < frameConversion2Size; ++i) {
if(frameID == frameConversion2[i][0]) {
header->setFrameID(frameConversion2[i][1]);
break;
}
}
break;
}
case 3: // ID3v2.3
{
if(frameID == "EQUA" ||
frameID == "RVAD" ||
frameID == "TIME" ||
frameID == "TRDA" ||
frameID == "TSIZ" ||
frameID == "TDAT")
{
debug("ID3v2.4 no longer supports the frame type " + String(frameID) +
". It will be discarded from the tag.");
return false;
}
for(size_t i = 0; i < frameConversion3Size; ++i) {
if(frameID == frameConversion3[i][0]) {
header->setFrameID(frameConversion3[i][1]);
break;
}
}
break;
}
default:
// This should catch a typo that existed in TagLib up to and including
// version 1.1 where TRDC was used for the year rather than TDRC.
if(frameID == "TRDC")
header->setFrameID("TDRC");
break;
}
return true;
}
Don't assume TDRC is an instance of TextIdentificationFrame (#831)
If TDRC is encrypted, FrameFactory::createFrame() returns UnknownFrame
which causes problems in rebuildAggregateFrames() when it is assumed
that TDRC is a TextIdentificationFrame
/***************************************************************************
copyright : (C) 2002 - 2008 by Scott Wheeler
email : wheeler@kde.org
***************************************************************************/
/***************************************************************************
* This library is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License version *
* 2.1 as published by the Free Software Foundation. *
* *
* This library is distributed in the hope that it will be useful, but *
* WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA *
* 02110-1301 USA *
* *
* Alternatively, this file is available under the Mozilla Public *
* License Version 1.1. You may obtain a copy of the License at *
* http://www.mozilla.org/MPL/ *
***************************************************************************/
#include <tdebug.h>
#include <tzlib.h>
#include "id3v2framefactory.h"
#include "id3v2synchdata.h"
#include "id3v1genres.h"
#include "frames/attachedpictureframe.h"
#include "frames/commentsframe.h"
#include "frames/relativevolumeframe.h"
#include "frames/textidentificationframe.h"
#include "frames/uniquefileidentifierframe.h"
#include "frames/unknownframe.h"
#include "frames/generalencapsulatedobjectframe.h"
#include "frames/urllinkframe.h"
#include "frames/unsynchronizedlyricsframe.h"
#include "frames/popularimeterframe.h"
#include "frames/privateframe.h"
#include "frames/ownershipframe.h"
#include "frames/synchronizedlyricsframe.h"
#include "frames/eventtimingcodesframe.h"
#include "frames/chapterframe.h"
#include "frames/tableofcontentsframe.h"
#include "frames/podcastframe.h"
using namespace TagLib;
using namespace ID3v2;
namespace
{
void updateGenre(TextIdentificationFrame *frame)
{
StringList fields = frame->fieldList();
StringList newfields;
for(StringList::ConstIterator it = fields.begin(); it != fields.end(); ++it) {
String s = *it;
int end = s.find(")");
if(s.startsWith("(") && end > 0) {
// "(12)Genre"
String text = s.substr(end + 1);
bool ok;
int number = s.substr(1, end - 1).toInt(&ok);
if(ok && number >= 0 && number <= 255 && !(ID3v1::genre(number) == text))
newfields.append(s.substr(1, end - 1));
if(!text.isEmpty())
newfields.append(text);
}
else {
// "Genre" or "12"
newfields.append(s);
}
}
if(newfields.isEmpty())
fields.append(String());
frame->setText(newfields);
}
}
class FrameFactory::FrameFactoryPrivate
{
public:
FrameFactoryPrivate() :
defaultEncoding(String::Latin1),
useDefaultEncoding(false) {}
String::Type defaultEncoding;
bool useDefaultEncoding;
template <class T> void setTextEncoding(T *frame)
{
if(useDefaultEncoding)
frame->setTextEncoding(defaultEncoding);
}
};
FrameFactory FrameFactory::factory;
////////////////////////////////////////////////////////////////////////////////
// public members
////////////////////////////////////////////////////////////////////////////////
FrameFactory *FrameFactory::instance()
{
return &factory;
}
Frame *FrameFactory::createFrame(const ByteVector &data, bool synchSafeInts) const
{
return createFrame(data, static_cast<unsigned int>(synchSafeInts ? 4 : 3));
}
Frame *FrameFactory::createFrame(const ByteVector &data, unsigned int version) const
{
Header tagHeader;
tagHeader.setMajorVersion(version);
return createFrame(data, &tagHeader);
}
Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader) const
{
ByteVector data = origData;
unsigned int version = tagHeader->majorVersion();
Frame::Header *header = new Frame::Header(data, version);
ByteVector frameID = header->frameID();
// A quick sanity check -- make sure that the frameID is 4 uppercase Latin1
// characters. Also make sure that there is data in the frame.
if(frameID.size() != (version < 3 ? 3 : 4) ||
header->frameSize() <= static_cast<unsigned int>(header->dataLengthIndicator() ? 4 : 0) ||
header->frameSize() > data.size())
{
delete header;
return 0;
}
#ifndef NO_ITUNES_HACKS
if(version == 3 && frameID.size() == 4 && frameID[3] == '\0') {
// iTunes v2.3 tags store v2.2 frames - convert now
frameID = frameID.mid(0, 3);
header->setFrameID(frameID);
header->setVersion(2);
updateFrame(header);
header->setVersion(3);
}
#endif
for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) {
if( (*it < 'A' || *it > 'Z') && (*it < '0' || *it > '9') ) {
delete header;
return 0;
}
}
if(version > 3 && (tagHeader->unsynchronisation() || header->unsynchronisation())) {
// Data lengths are not part of the encoded data, but since they are synch-safe
// integers they will be never actually encoded.
ByteVector frameData = data.mid(Frame::Header::size(version), header->frameSize());
frameData = SynchData::decode(frameData);
data = data.mid(0, Frame::Header::size(version)) + frameData;
}
// TagLib doesn't mess with encrypted frames, so just treat them
// as unknown frames.
if(!zlib::isAvailable() && header->compression()) {
debug("Compressed frames are currently not supported.");
return new UnknownFrame(data, header);
}
if(header->encryption()) {
debug("Encrypted frames are currently not supported.");
return new UnknownFrame(data, header);
}
if(!updateFrame(header)) {
header->setTagAlterPreservation(true);
return new UnknownFrame(data, header);
}
// updateFrame() might have updated the frame ID.
frameID = header->frameID();
// This is where things get necissarily nasty. Here we determine which
// Frame subclass (or if none is found simply an Frame) based
// on the frame ID. Since there are a lot of possibilities, that means
// a lot of if blocks.
// Text Identification (frames 4.2)
// Apple proprietary WFED (Podcast URL), MVNM (Movement Name), MVIN (Movement Number) are in fact text frames.
if(frameID.startsWith("T") || frameID == "WFED" || frameID == "MVNM" || frameID == "MVIN") {
TextIdentificationFrame *f = frameID != "TXXX"
? new TextIdentificationFrame(data, header)
: new UserTextIdentificationFrame(data, header);
d->setTextEncoding(f);
if(frameID == "TCON")
updateGenre(f);
return f;
}
// Comments (frames 4.10)
if(frameID == "COMM") {
CommentsFrame *f = new CommentsFrame(data, header);
d->setTextEncoding(f);
return f;
}
// Attached Picture (frames 4.14)
if(frameID == "APIC") {
AttachedPictureFrame *f = new AttachedPictureFrame(data, header);
d->setTextEncoding(f);
return f;
}
// ID3v2.2 Attached Picture
if(frameID == "PIC") {
AttachedPictureFrame *f = new AttachedPictureFrameV22(data, header);
d->setTextEncoding(f);
return f;
}
// Relative Volume Adjustment (frames 4.11)
if(frameID == "RVA2")
return new RelativeVolumeFrame(data, header);
// Unique File Identifier (frames 4.1)
if(frameID == "UFID")
return new UniqueFileIdentifierFrame(data, header);
// General Encapsulated Object (frames 4.15)
if(frameID == "GEOB") {
GeneralEncapsulatedObjectFrame *f = new GeneralEncapsulatedObjectFrame(data, header);
d->setTextEncoding(f);
return f;
}
// URL link (frames 4.3)
if(frameID.startsWith("W")) {
if(frameID != "WXXX") {
return new UrlLinkFrame(data, header);
}
else {
UserUrlLinkFrame *f = new UserUrlLinkFrame(data, header);
d->setTextEncoding(f);
return f;
}
}
// Unsynchronized lyric/text transcription (frames 4.8)
if(frameID == "USLT") {
UnsynchronizedLyricsFrame *f = new UnsynchronizedLyricsFrame(data, header);
if(d->useDefaultEncoding)
f->setTextEncoding(d->defaultEncoding);
return f;
}
// Synchronised lyrics/text (frames 4.9)
if(frameID == "SYLT") {
SynchronizedLyricsFrame *f = new SynchronizedLyricsFrame(data, header);
if(d->useDefaultEncoding)
f->setTextEncoding(d->defaultEncoding);
return f;
}
// Event timing codes (frames 4.5)
if(frameID == "ETCO")
return new EventTimingCodesFrame(data, header);
// Popularimeter (frames 4.17)
if(frameID == "POPM")
return new PopularimeterFrame(data, header);
// Private (frames 4.27)
if(frameID == "PRIV")
return new PrivateFrame(data, header);
// Ownership (frames 4.22)
if(frameID == "OWNE") {
OwnershipFrame *f = new OwnershipFrame(data, header);
d->setTextEncoding(f);
return f;
}
// Chapter (ID3v2 chapters 1.0)
if(frameID == "CHAP")
return new ChapterFrame(tagHeader, data, header);
// Table of contents (ID3v2 chapters 1.0)
if(frameID == "CTOC")
return new TableOfContentsFrame(tagHeader, data, header);
// Apple proprietary PCST (Podcast)
if(frameID == "PCST")
return new PodcastFrame(data, header);
return new UnknownFrame(data, header);
}
void FrameFactory::rebuildAggregateFrames(ID3v2::Tag *tag) const
{
if(tag->header()->majorVersion() < 4 &&
tag->frameList("TDRC").size() == 1 &&
tag->frameList("TDAT").size() == 1)
{
TextIdentificationFrame *tdrc =
dynamic_cast<TextIdentificationFrame *>(tag->frameList("TDRC").front());
UnknownFrame *tdat = static_cast<UnknownFrame *>(tag->frameList("TDAT").front());
if(tdrc &&
tdrc->fieldList().size() == 1 &&
tdrc->fieldList().front().size() == 4 &&
tdat->data().size() >= 5)
{
String date(tdat->data().mid(1), String::Type(tdat->data()[0]));
if(date.length() == 4) {
tdrc->setText(tdrc->toString() + '-' + date.substr(2, 2) + '-' + date.substr(0, 2));
if(tag->frameList("TIME").size() == 1) {
UnknownFrame *timeframe = static_cast<UnknownFrame *>(tag->frameList("TIME").front());
if(timeframe->data().size() >= 5) {
String time(timeframe->data().mid(1), String::Type(timeframe->data()[0]));
if(time.length() == 4) {
tdrc->setText(tdrc->toString() + 'T' + time.substr(0, 2) + ':' + time.substr(2, 2));
}
}
}
}
}
}
}
String::Type FrameFactory::defaultTextEncoding() const
{
return d->defaultEncoding;
}
void FrameFactory::setDefaultTextEncoding(String::Type encoding)
{
d->useDefaultEncoding = true;
d->defaultEncoding = encoding;
}
////////////////////////////////////////////////////////////////////////////////
// protected members
////////////////////////////////////////////////////////////////////////////////
FrameFactory::FrameFactory() :
d(new FrameFactoryPrivate())
{
}
FrameFactory::~FrameFactory()
{
delete d;
}
namespace
{
// Frame conversion table ID3v2.2 -> 2.4
const char *frameConversion2[][2] = {
{ "BUF", "RBUF" },
{ "CNT", "PCNT" },
{ "COM", "COMM" },
{ "CRA", "AENC" },
{ "ETC", "ETCO" },
{ "GEO", "GEOB" },
{ "IPL", "TIPL" },
{ "MCI", "MCDI" },
{ "MLL", "MLLT" },
{ "POP", "POPM" },
{ "REV", "RVRB" },
{ "SLT", "SYLT" },
{ "STC", "SYTC" },
{ "TAL", "TALB" },
{ "TBP", "TBPM" },
{ "TCM", "TCOM" },
{ "TCO", "TCON" },
{ "TCP", "TCMP" },
{ "TCR", "TCOP" },
{ "TDY", "TDLY" },
{ "TEN", "TENC" },
{ "TFT", "TFLT" },
{ "TKE", "TKEY" },
{ "TLA", "TLAN" },
{ "TLE", "TLEN" },
{ "TMT", "TMED" },
{ "TOA", "TOAL" },
{ "TOF", "TOFN" },
{ "TOL", "TOLY" },
{ "TOR", "TDOR" },
{ "TOT", "TOAL" },
{ "TP1", "TPE1" },
{ "TP2", "TPE2" },
{ "TP3", "TPE3" },
{ "TP4", "TPE4" },
{ "TPA", "TPOS" },
{ "TPB", "TPUB" },
{ "TRC", "TSRC" },
{ "TRD", "TDRC" },
{ "TRK", "TRCK" },
{ "TS2", "TSO2" },
{ "TSA", "TSOA" },
{ "TSC", "TSOC" },
{ "TSP", "TSOP" },
{ "TSS", "TSSE" },
{ "TST", "TSOT" },
{ "TT1", "TIT1" },
{ "TT2", "TIT2" },
{ "TT3", "TIT3" },
{ "TXT", "TOLY" },
{ "TXX", "TXXX" },
{ "TYE", "TDRC" },
{ "UFI", "UFID" },
{ "ULT", "USLT" },
{ "WAF", "WOAF" },
{ "WAR", "WOAR" },
{ "WAS", "WOAS" },
{ "WCM", "WCOM" },
{ "WCP", "WCOP" },
{ "WPB", "WPUB" },
{ "WXX", "WXXX" },
// Apple iTunes nonstandard frames
{ "PCS", "PCST" },
{ "TCT", "TCAT" },
{ "TDR", "TDRL" },
{ "TDS", "TDES" },
{ "TID", "TGID" },
{ "WFD", "WFED" },
{ "MVN", "MVNM" },
{ "MVI", "MVIN" },
};
const size_t frameConversion2Size = sizeof(frameConversion2) / sizeof(frameConversion2[0]);
// Frame conversion table ID3v2.3 -> 2.4
const char *frameConversion3[][2] = {
{ "TORY", "TDOR" },
{ "TYER", "TDRC" },
{ "IPLS", "TIPL" },
};
const size_t frameConversion3Size = sizeof(frameConversion3) / sizeof(frameConversion3[0]);
}
bool FrameFactory::updateFrame(Frame::Header *header) const
{
const ByteVector frameID = header->frameID();
switch(header->version()) {
case 2: // ID3v2.2
{
if(frameID == "CRM" ||
frameID == "EQU" ||
frameID == "LNK" ||
frameID == "RVA" ||
frameID == "TIM" ||
frameID == "TSI" ||
frameID == "TDA")
{
debug("ID3v2.4 no longer supports the frame type " + String(frameID) +
". It will be discarded from the tag.");
return false;
}
// ID3v2.2 only used 3 bytes for the frame ID, so we need to convert all of
// the frames to their 4 byte ID3v2.4 equivalent.
for(size_t i = 0; i < frameConversion2Size; ++i) {
if(frameID == frameConversion2[i][0]) {
header->setFrameID(frameConversion2[i][1]);
break;
}
}
break;
}
case 3: // ID3v2.3
{
if(frameID == "EQUA" ||
frameID == "RVAD" ||
frameID == "TIME" ||
frameID == "TRDA" ||
frameID == "TSIZ" ||
frameID == "TDAT")
{
debug("ID3v2.4 no longer supports the frame type " + String(frameID) +
". It will be discarded from the tag.");
return false;
}
for(size_t i = 0; i < frameConversion3Size; ++i) {
if(frameID == frameConversion3[i][0]) {
header->setFrameID(frameConversion3[i][1]);
break;
}
}
break;
}
default:
// This should catch a typo that existed in TagLib up to and including
// version 1.1 where TRDC was used for the year rather than TDRC.
if(frameID == "TRDC")
header->setFrameID("TDRC");
break;
}
return true;
}
|
#include "MusicBar.h"
MusicBar::MusicBar(SongPlayer *songPlayer)
{
mPlayer = songPlayer;
musicbarSurfaceWidth = 1080;
musicbarSurfaceHeight = 64;
surface = SDL_CreateRGBSurface(0, musicbarSurfaceWidth, musicbarSurfaceHeight, 32, 0, 0, 0, 0);
init();
}
int MusicBar::init()
{
int songNameFontSize;
int timeFontSize;
songNameFontSize = 45;
timeFontSize = 25;
if (TTF_Init() !=0)
{
fprintf(stderr, "TTF_Init Failed%s\n", TTF_GetError());
SDL_Quit();
exit(1);
}
songNameFont = TTF_OpenFont("assets/ant-maru.ttf", songNameFontSize);
if (songNameFont == NULL)
{
fprintf(stderr, "TTF_OpenFont Failed%s\n", TTF_GetError());
TTF_Quit();
SDL_Quit();
exit(1);
}
timeFont = TTF_OpenFont("assets/Trebuchet-MS.ttf", timeFontSize);
if (timeFont == NULL)
{
fprintf(stderr, "TTF_OpenFont Failed%s\n", TTF_GetError());
TTF_Quit();
SDL_Quit();
exit(1);
}
}
void MusicBar::drawSongName()
{
std::string songName;
int songStringLength;
const char * songChar;
int songWidth;
int songHeight;
songName = mPlayer->currentSong();
songStringLength = songName.length();
songName = songName.substr(12, songStringLength - 16); // removes SongLibrary/ and .mp3 from songName
songChar = songName.c_str();
// SDL CALLS //
SDL_Surface *songSurface;
SDL_Color songColor = {255, 255, 255};
songSurface = TTF_RenderUTF8_Blended(songNameFont, songChar, songColor);
TTF_SizeText(songNameFont, songChar, &songWidth, &songHeight);
SDL_Rect songLocation = {musicbarSurfaceWidth/2 - songWidth/2, musicbarSurfaceHeight/2 - songHeight/2, 0, 0};
SDL_BlitSurface(songSurface, NULL, surface, &songLocation);
SDL_FreeSurface(songSurface);
}
std::string MusicBar::convertToString(int songIntTime)
{
std::string songStringTime;
std::stringstream convertSongIntTime;
convertSongIntTime << songIntTime;
songStringTime = convertSongIntTime.str();
return songStringTime;
}
void MusicBar::drawSongTime()
{
double songCurrentTime;
int songCurrentMins;
int songCurrentSecs;
double songCurrentPercent;
int songCurrentIntTime;
std::string songCurrentStrTime;
std::string songCurrentStrMins;
std::string songCurrentStrSecs;
const char * songCurrentCharTime;
double songTotalTime;
int songTotalMins;
int songTotalSecs;
int songTotalIntTime;
std::string songTotalStrTime;
std::string songTotalStrMins;
std::string songTotalStrSecs;
const char * songTotalCharTime;
int totalTimeWidth;
int totalTimeHeight;
songCurrentTime = mPlayer->getCurrentTime();
songTotalTime = mPlayer->getSongLength();
songCurrentPercent = songCurrentTime / songTotalTime;
songCurrentIntTime = songCurrentTime;
songCurrentMins = songCurrentIntTime / 60;
songCurrentSecs = songCurrentIntTime % 60;
//songTotalTime = songTotalTime - songCurrentTime; // Remove to stop end time increment
songTotalIntTime = songTotalTime;
songTotalMins = songTotalTime / 60;
songTotalSecs = songTotalIntTime % 60;
songCurrentStrMins = convertToString(songCurrentMins);
songCurrentStrSecs = convertToString(songCurrentSecs);
if (songCurrentSecs < 10)
{
songCurrentStrTime = songCurrentStrMins + ":0" +
songCurrentStrSecs;
}
else
{
songCurrentStrTime = songCurrentStrMins + ":" + songCurrentStrSecs;
}
songCurrentCharTime = songCurrentStrTime.c_str();
songTotalStrMins = convertToString(songTotalMins);
songTotalStrSecs = convertToString(songTotalSecs);
if (songTotalSecs < 10)
{
songTotalStrTime = songTotalStrMins + ":0" + songTotalStrSecs;
}
else
{
songTotalStrTime = songTotalStrMins + ":" + songTotalStrSecs;
}
songTotalCharTime = songTotalStrTime.c_str();
// SDL CALLS//
SDL_Color songTimeColor = {255, 255, 255};
SDL_Surface *songCurrentTimeSurface;
songCurrentTimeSurface = TTF_RenderText_Blended(timeFont, songCurrentCharTime, songTimeColor);
SDL_Rect songCurrentTimeLocation = {0, 4, 0, 0};
SDL_BlitSurface(songCurrentTimeSurface, NULL, surface, &songCurrentTimeLocation);
SDL_FreeSurface(songCurrentTimeSurface);
SDL_Surface *songTotalTimeSurface;
songTotalTimeSurface = TTF_RenderText_Blended(timeFont, songTotalCharTime, songTimeColor);
TTF_SizeText(timeFont, songTotalCharTime, &totalTimeWidth, &totalTimeHeight);
SDL_Rect songTotalTimeLocation = {musicbarSurfaceWidth - totalTimeWidth, 4, 0};
SDL_BlitSurface(songTotalTimeSurface, NULL, surface, &songTotalTimeLocation);
SDL_FreeSurface(songTotalTimeSurface);
SDL_Surface *songTimebarSurface;
songTimebarSurface = SDL_CreateRGBSurface(0, 0 + songCurrentPercent*musicbarSurfaceWidth, 3, 32, 0, 0, 0, 0);
SDL_FillRect(songTimebarSurface, NULL, SDL_MapRGB(songTimebarSurface->format,0,162,255));
SDL_Rect songTimebarLocation = {0, 0, 0, 0};
SDL_BlitSurface(songTimebarSurface, NULL, surface, &songTimebarLocation);
SDL_FreeSurface(songTimebarSurface);
}
void MusicBar::drawVolumeBar()
{
double songVolumeCurrent;
double songVolumePercent;
double songVolumeMax;
songVolumeMax = 2.0;
songVolumeCurrent = mPlayer->getVolume();
songVolumePercent = songVolumeCurrent / songVolumeMax;
// Volume Background Bar
SDL_Surface *volumeBackgroundSurface;
int volumeBarHeight;
int volumeBarXLocation;
int volumeBarYLocation;
int volumeBarNumber;
int i;
int colorGreen;
volumeBarNumber = 20;
volumeBarHeight = 4;
volumeBarXLocation = 880;
volumeBarYLocation = 50;
for (i = 0; i < volumeBarNumber; i++)
{
volumeBackgroundSurface = SDL_CreateRGBSurface(0,4, volumeBarHeight,32,0,0,0,0);
SDL_FillRect(volumeBackgroundSurface, NULL, SDL_MapRGB(volumeBackgroundSurface->format,0,0,0));
SDL_Rect volumeBarLocation = {volumeBarXLocation,volumeBarYLocation,0,0};
SDL_BlitSurface(volumeBackgroundSurface, NULL, surface, &volumeBarLocation);
SDL_FreeSurface(volumeBackgroundSurface);
//Increments for changing bar size
volumeBarHeight += 2;
volumeBarXLocation += 6;
volumeBarYLocation -= 2;
}
// Volume bar
SDL_Surface *volumeSurface;
volumeBarHeight = 4;
volumeBarXLocation = 880;
volumeBarYLocation = 50;
colorGreen = 162;
songVolumePercent = songVolumePercent * volumeBarNumber - 0.1;
for (i = 0; i < songVolumePercent; i++)
{
volumeSurface = SDL_CreateRGBSurface(0,4, volumeBarHeight, 32,0,0,0,0);
SDL_FillRect(volumeSurface, NULL, SDL_MapRGB(volumeSurface->format,255,colorGreen,0));
SDL_Rect volumeBarLocation = {volumeBarXLocation, volumeBarYLocation, 0, 0};
SDL_BlitSurface(volumeSurface, NULL, surface, &volumeBarLocation);
SDL_FreeSurface(volumeSurface);
// Increments for changing bar size and gradient
volumeBarHeight += 2;
colorGreen -= 6;
volumeBarXLocation += 6;
volumeBarYLocation -= 2;
}
}
void MusicBar::update()
{
SDL_FillRect(surface, NULL, SDL_MapRGB(surface->format,43,43,43));
drawSongName();
drawSongTime();
drawVolumeBar();
}
SDL_Surface* MusicBar::returnMusicBar()
{
return surface;
}
Fonts are now looking at /usr/share/fonts
#include "MusicBar.h"
MusicBar::MusicBar(SongPlayer *songPlayer)
{
mPlayer = songPlayer;
musicbarSurfaceWidth = 1080;
musicbarSurfaceHeight = 64;
surface = SDL_CreateRGBSurface(0, musicbarSurfaceWidth, musicbarSurfaceHeight, 32, 0, 0, 0, 0);
init();
}
int MusicBar::init()
{
int songNameFontSize;
int timeFontSize;
songNameFontSize = 45;
timeFontSize = 25;
if (TTF_Init() !=0)
{
fprintf(stderr, "TTF_Init Failed%s\n", TTF_GetError());
SDL_Quit();
exit(1);
}
songNameFont = TTF_OpenFont("/usr/share/fonts/ant-maru.ttf", songNameFontSize);
if (songNameFont == NULL)
{
fprintf(stderr, "TTF_OpenFont Failed%s\n", TTF_GetError());
TTF_Quit();
SDL_Quit();
exit(1);
}
timeFont = TTF_OpenFont("/usr/share/fonts/Trebuchet-MS.ttf", timeFontSize);
if (timeFont == NULL)
{
fprintf(stderr, "TTF_OpenFont Failed%s\n", TTF_GetError());
TTF_Quit();
SDL_Quit();
exit(1);
}
}
void MusicBar::drawSongName()
{
std::string songName;
int songStringLength;
const char * songChar;
int songWidth;
int songHeight;
songName = mPlayer->currentSong();
songStringLength = songName.length();
songName = songName.substr(12, songStringLength - 16); // removes SongLibrary/ and .mp3 from songName
songChar = songName.c_str();
// SDL CALLS //
SDL_Surface *songSurface;
SDL_Color songColor = {255, 255, 255};
songSurface = TTF_RenderUTF8_Blended(songNameFont, songChar, songColor);
TTF_SizeText(songNameFont, songChar, &songWidth, &songHeight);
SDL_Rect songLocation = {musicbarSurfaceWidth/2 - songWidth/2, musicbarSurfaceHeight/2 - songHeight/2, 0, 0};
SDL_BlitSurface(songSurface, NULL, surface, &songLocation);
SDL_FreeSurface(songSurface);
}
std::string MusicBar::convertToString(int songIntTime)
{
std::string songStringTime;
std::stringstream convertSongIntTime;
convertSongIntTime << songIntTime;
songStringTime = convertSongIntTime.str();
return songStringTime;
}
void MusicBar::drawSongTime()
{
double songCurrentTime;
int songCurrentMins;
int songCurrentSecs;
double songCurrentPercent;
int songCurrentIntTime;
std::string songCurrentStrTime;
std::string songCurrentStrMins;
std::string songCurrentStrSecs;
const char * songCurrentCharTime;
double songTotalTime;
int songTotalMins;
int songTotalSecs;
int songTotalIntTime;
std::string songTotalStrTime;
std::string songTotalStrMins;
std::string songTotalStrSecs;
const char * songTotalCharTime;
int totalTimeWidth;
int totalTimeHeight;
songCurrentTime = mPlayer->getCurrentTime();
songTotalTime = mPlayer->getSongLength();
songCurrentPercent = songCurrentTime / songTotalTime;
songCurrentIntTime = songCurrentTime;
songCurrentMins = songCurrentIntTime / 60;
songCurrentSecs = songCurrentIntTime % 60;
//songTotalTime = songTotalTime - songCurrentTime; // Remove to stop end time increment
songTotalIntTime = songTotalTime;
songTotalMins = songTotalTime / 60;
songTotalSecs = songTotalIntTime % 60;
songCurrentStrMins = convertToString(songCurrentMins);
songCurrentStrSecs = convertToString(songCurrentSecs);
if (songCurrentSecs < 10)
{
songCurrentStrTime = songCurrentStrMins + ":0" +
songCurrentStrSecs;
}
else
{
songCurrentStrTime = songCurrentStrMins + ":" + songCurrentStrSecs;
}
songCurrentCharTime = songCurrentStrTime.c_str();
songTotalStrMins = convertToString(songTotalMins);
songTotalStrSecs = convertToString(songTotalSecs);
if (songTotalSecs < 10)
{
songTotalStrTime = songTotalStrMins + ":0" + songTotalStrSecs;
}
else
{
songTotalStrTime = songTotalStrMins + ":" + songTotalStrSecs;
}
songTotalCharTime = songTotalStrTime.c_str();
// SDL CALLS//
SDL_Color songTimeColor = {255, 255, 255};
SDL_Surface *songCurrentTimeSurface;
songCurrentTimeSurface = TTF_RenderText_Blended(timeFont, songCurrentCharTime, songTimeColor);
SDL_Rect songCurrentTimeLocation = {0, 4, 0, 0};
SDL_BlitSurface(songCurrentTimeSurface, NULL, surface, &songCurrentTimeLocation);
SDL_FreeSurface(songCurrentTimeSurface);
SDL_Surface *songTotalTimeSurface;
songTotalTimeSurface = TTF_RenderText_Blended(timeFont, songTotalCharTime, songTimeColor);
TTF_SizeText(timeFont, songTotalCharTime, &totalTimeWidth, &totalTimeHeight);
SDL_Rect songTotalTimeLocation = {musicbarSurfaceWidth - totalTimeWidth, 4, 0};
SDL_BlitSurface(songTotalTimeSurface, NULL, surface, &songTotalTimeLocation);
SDL_FreeSurface(songTotalTimeSurface);
SDL_Surface *songTimebarSurface;
songTimebarSurface = SDL_CreateRGBSurface(0, 0 + songCurrentPercent*musicbarSurfaceWidth, 3, 32, 0, 0, 0, 0);
SDL_FillRect(songTimebarSurface, NULL, SDL_MapRGB(songTimebarSurface->format,0,162,255));
SDL_Rect songTimebarLocation = {0, 0, 0, 0};
SDL_BlitSurface(songTimebarSurface, NULL, surface, &songTimebarLocation);
SDL_FreeSurface(songTimebarSurface);
}
void MusicBar::drawVolumeBar()
{
double songVolumeCurrent;
double songVolumePercent;
double songVolumeMax;
songVolumeMax = 2.0;
songVolumeCurrent = mPlayer->getVolume();
songVolumePercent = songVolumeCurrent / songVolumeMax;
// Volume Background Bar
SDL_Surface *volumeBackgroundSurface;
int volumeBarHeight;
int volumeBarXLocation;
int volumeBarYLocation;
int volumeBarNumber;
int i;
int colorGreen;
volumeBarNumber = 20;
volumeBarHeight = 4;
volumeBarXLocation = 880;
volumeBarYLocation = 50;
for (i = 0; i < volumeBarNumber; i++)
{
volumeBackgroundSurface = SDL_CreateRGBSurface(0,4, volumeBarHeight,32,0,0,0,0);
SDL_FillRect(volumeBackgroundSurface, NULL, SDL_MapRGB(volumeBackgroundSurface->format,0,0,0));
SDL_Rect volumeBarLocation = {volumeBarXLocation,volumeBarYLocation,0,0};
SDL_BlitSurface(volumeBackgroundSurface, NULL, surface, &volumeBarLocation);
SDL_FreeSurface(volumeBackgroundSurface);
//Increments for changing bar size
volumeBarHeight += 2;
volumeBarXLocation += 6;
volumeBarYLocation -= 2;
}
// Volume bar
SDL_Surface *volumeSurface;
volumeBarHeight = 4;
volumeBarXLocation = 880;
volumeBarYLocation = 50;
colorGreen = 162;
songVolumePercent = songVolumePercent * volumeBarNumber - 0.1;
for (i = 0; i < songVolumePercent; i++)
{
volumeSurface = SDL_CreateRGBSurface(0,4, volumeBarHeight, 32,0,0,0,0);
SDL_FillRect(volumeSurface, NULL, SDL_MapRGB(volumeSurface->format,255,colorGreen,0));
SDL_Rect volumeBarLocation = {volumeBarXLocation, volumeBarYLocation, 0, 0};
SDL_BlitSurface(volumeSurface, NULL, surface, &volumeBarLocation);
SDL_FreeSurface(volumeSurface);
// Increments for changing bar size and gradient
volumeBarHeight += 2;
colorGreen -= 6;
volumeBarXLocation += 6;
volumeBarYLocation -= 2;
}
}
void MusicBar::update()
{
SDL_FillRect(surface, NULL, SDL_MapRGB(surface->format,43,43,43));
drawSongName();
drawSongTime();
drawVolumeBar();
}
SDL_Surface* MusicBar::returnMusicBar()
{
return surface;
}
|
#include "LIGHT.H"
#include "EFFECT2.H"
#include "DRAW.H"
#include "MATHS.H"
#include "LOAD_LEV.H"
#include "GTEREG.H"
#include "MISC.H"
#include "DRAWSPKS.H"
void mNormaliseXYZ_L(int* x, int* y, int* z)//86500 (F)
{
IR1 = *x;
IR2 = *y;
IR3 = *z;
int a3 = 0x1F;
docop2(0xA00428);
int v0 = MAC1;
int v1 = MAC2;
int at = MAC3;
v0 += v1;
v0 += at;
LZCR = gte_leadingzerocount(v0);
LZCS = v0;
IR1 = *x;
IR2 = *y;
v1 = LZCR;
at = -2;
v1 &= at;
a3 -= v1;
a3 >>= 1;
at = v1 - 24;
if (at >= 0)
{
v0 <<= at;
}
else
{
//loc_8655C
at = 24;
at -= v1;
v0 >>= at;
}
//loc_86568
v0 -= 64;
v0 = ScalarTable[v0];
IR3 = *z;
IR0 = v0;
docop2(0x190003D);
*x = MAC1;
*y = MAC2;
*z = MAC3;
*x >>= a3;
*y >>= a3;
*z >>= a3;
}
int mSqrt_L(int a0)//8649C (F)
{
LZCR = gte_leadingzerocount(a0);
LZCS = a0;
int v0 = 0x1F;
if (a0 != 0)
{
int v1 = LZCR;
int at = -2;
v1 &= at;
v0 -= v1;
v0 >>= 1;
at = v1 - 24;
if (at >= 0)
{
a0 <<= at;
}
else
{
at = 24;
at -= v1;
a0 >>= at;
}
//loc_864DC
a0 -= 64;
a0 = SqrtTable[a0];
a0 <<= v0;
}
//locret_864F8
return a0 >> 12;
}
void S_CalculateStaticMeshLight(long floor, long touch_bits, long mesh_bits, int anim_state)//8669C(<)
{
int t5 = 0;
int t4 = 0;
int t3 = 0;
int t7;
int t6;
int t0;
int a0;
int a1;
int a2;
int v1;
int at;
int v0;
int i;
if (number_dynamics > 0)
{
t7 = floor;
t6 = touch_bits;
t0 = mesh_bits;
//loc_866C4
for(i = 0; i < number_dynamics; i++)
{
IR1 = floor - dynamics[i].x;
//loc_866E4
if (ABS(IR1) < 0x2001)
{
IR2 = touch_bits - dynamics[i].y;
if (ABS(IR1) < 0x2001)
{
IR2 = mesh_bits - dynamics[i].z;
if (ABS(IR2) < 0x2001)
{
docop2(0xA00428);
a0 = MAC1;
a1 = MAC2;
a2 = MAC3;
a0 += a1;
a0 += a2;
a0 = gte_leadingzerocount(a0);
v0 = 0x1F;
if (a0 != 0)
{
v1 = LZCR;
at = -2;
v1 &= at;
v0 -= v1;
v0 >>= 1;
at = v1 - 0x18;
if (at >= 0)
{
a0 <<= at;
}//loc_86774
else
{
at = 0x18;
at -= v1;
a0 >>= at;
}
//loc_86780
a0 -= 0x40;
a0 = SqrtTable[a0];
a0 <<= v0;
}
//loc_8679C
v0 = a0 >> 12;
v1 = dynamics[i].falloff >> 1;
a0 = v0;
v0 = a0 << 13;
if (v1 >= a0)
{
v0 -= a0;
v0 = v0 / v1;
v1 = 0x1FFF;
a0 = dynamics[i].r;
v1 -= v0;
at = a0 * v1;
v0 = dynamics[i].g;
a0 = v0 * v1;
v0 = dynamics[i].b;
v1 = v0 * v1;
v0 = at >> 13;
t3 += v0;
v0 = a0 >> 13;
t4 += v0;
v0 = v1 >> 13;
t5 += v0;
}
}//loc_86810
}//loc_86810
}//loc_86810
}
}//loc_8681C
v0 = t3 + t4;
v0 += t5;
a0 = anim_state;
if (v0 != 0)
{
v0 = anim_state & 0x1F;
v0 <<= 3;
t3 += v0;
v1 = anim_state & 0x3E0;
v1 >>= 2;
t4 += v1;
v1 = anim_state & 0x7C00;
v1 >>= 7;
t5 += v1;
if (t3 >= 0x100)
{
t3 = 0xFF;
}//loc_86860
if (t4 >= 0x100)
{
t4 = 0xFF;
}//loc_8686C
if (t5 >= 0x100)
{
t5 = 0xFF;
}//loc_86878
t4 <<= 8;
t5 <<= 16;
a0 = t3 | t4 | t5;
}
else
{
//loc_8688C
v1 = a0 & 0x3E0;
v0 = a0 & 0x7C00;
a0 &= 0x1F;
a0 <<= 3;
v1 <<= 6;
v0 <<= 9;
a0 |= v1;
a0 |= v0;
}
R = (a0 & 0xFF);
G = (a0 & 0xFF00) >> 8;
B = (a0 & 0xFF0000) >> 16;
CODE = (a0 & 0xFF000000) >> 24;
}
void CalculateObjectLighting(struct ITEM_INFO* item/*a0*/, short* frmptr/*a1*/, struct STASHEDOBJ* sobject/*s0*/, short numnodestodraw/*s1*/)
{
if (item->shade < 0)
{
R11 = 4096;
R12 = 0;
R13 = 0;
R21 = 0;
R22 = 4096;
R23 = 0;
R31 = 0;
R32 = 0;
R33 = 4096;
TRX = 0;
TRY = 0;
TRZ = 0;
Matrix++;
mRotYXZ(item->pos.y_rot, item->pos.x_rot, item->pos.z_rot);
mTranslateXYZ((frmptr[0] + frmptr[1]) >> 1, (frmptr[2] + frmptr[4]) >> 1, (frmptr[3] + frmptr[5]) >> 1);
mPopMatrix();
//S_CalculateLight(item->pos.x_pos + TRX, item->pos.y_pos + TRY, item->pos.z_pos + TRZ, item->room_number, &item->il);
}
else
{
//loc_8668C
S_CalculateStaticMeshLight(item->pos.x_pos, item->pos.y_pos, item->pos.z_pos, 0x7FFF);
}
}
void S_CalculateLight(long x, long y, long z, short room_num, struct ITEM_LIGHT* light)
{
struct room_info* r;//$t0
int scratchPad[256];
int t3;
int t4;
int t5;
int t6;
S_MemSet((char*)&scratchPad[0], 0, 1024);
int* s1 = &scratchPad[21];
//at = 0x1000
s1[3] = 0;
s1[4] = 0;
((short*)s1)[10] = 0x1000;
int* s2 = &s1[8];
s2[3] = 0;
s2[4] = 0;
((short*)s2)[10] = 0x1000;
int* s3 = &s2[8];
s3[3] = 0;
s3[4] = 0;
((short*)s3)[10] = 0x1000;
int s4 = 0;
int s5 = 0;
int s6 = 0;
int s7 = 4096;
int t7 = x;
int t8 = y;
int t9 = z;
//t0 = &room[0];
//s0 = gp
r = &room[room_num];
struct LIGHTINFO* gp = r->light;
int v0 = ((int*)&r->ambient)[0];
unsigned short fp = r->num_lights;
int t2 = (v0 >> 12) & 0xFF0;
int t1 = (v0 >> 4) & 0xFF0;
int t0 = (v0 << 4) & 0xFF0;
SXY0 = t0;
SXY1 = t1;
SXY2 = t2;
loc_85D34:
if (fp-- != 0)
{
int t3 = gp->Type;
int t2 = ((int*)&gp->Inner)[0];
int t0 = t2 & 0xFF00;
if (gp->Type == 0)
{
s4 |= 0x2000;
int a0 = ((int*)&gp->nx)[0];
int a1 = ((int*)&gp->nz)[0];
int a2 = ((int*)&gp->Type)[0];
s1[4] = a0;
s1[5] = a1;
s1[3] = a2;
gp++;
goto loc_85D34;
}
else
{
//loc_85D70
t4 = gp->x;
t5 = gp->y;
t6 = gp->z;
t4 -= t7;
t5 -= t8;
t6 -= t9;
IR1 = t4;
IR2 = t5;
IR3 = t6;
t0 >>= 1;
docop2(0xA00428);
t1 = (t2 & 0xFF) << 7;
t2 >>= 16;
int a3 = t3 & 1;
int a0 = MAC1;
int a1 = MAC2;
int a2 = MAC3;
a0 += a1;
a0 += a2;
int v0 = mSqrt_L(a0);
a0 = t4;
if (v0 < t0)
{
a1 = t5;
a2 = t6;
if (a3 != 0)
{
t4 = v0;
mNormaliseXYZ_L(&a0, &a1, &a2);
t5 = gp->Intensity;
a3 = t5;
if (t4 >= t1)
{
t4 -= t1;
t5 = t0 - t1;
t5 -= t4;
a3 = (t5 * t2) >> 8;
}
//loc_85E0C
int at = 4096;
if (t3 - 3 == 0)
{
a3 = at - a3;
if (a3 < s7)
{
gp++;
s7 = a3;
}
goto loc_85D34;
}
goto loc_85ED0;
}
else
{
//loc_85E30
t4 = v0;
mNormaliseXYZ_L(&a0, &a1, &a2);
v0 = (R11 & 0xFFFF) | (R12 << 16) & 0xFFFF;
int v1 = (R13 & 0xFFFF) | (R21 << 16) & 0xFFFF;
VX0 = ((int*)&gp->nx)[0] & 0xFFFF;
VY0 = (((int*)&gp->nx)[0] >> 16) & 0xFFFF;
VZ0 = ((int*)&gp->nz)[0] & 0xFFFF;
a1 <<= 16;
a0 &= 0xFFFF;
a0 |= a1;
R11 = a0 & 0xFFFF;
R12 = (a0 >> 16) & 0xFFFF;
R13 = a2 & 0xFFFF;
R21 = (a2 >> 16) & 0xFFFF;
t3 = t4 - t1;
docop2(0x486012);
t5 = t0 - t1;
t5 -= t3;
t1 = t5 * t2;
t5 = ((int*)&gp->Length)[0];
t3 = ((unsigned short*)&gp->Intensity)[0];
t6 = t5 >> 16;
t0 = IR1;
R11 = v0 & 0xFFFF;
R12 = (v0 >> 16) & 0xFFFF;
R13 = v1 & 0xFFFF;
R21 = (v1 >> 16) & 0xFFFF;
t5 &= 0xFFFF;
if (t0 >= t6)
{
if (t0 >= t5)
{
t0 = 4096;
}
//loc_85EA4
t1 >>= 8;
a0 = (VX0 & 0xFFFF) | ((VY0 & 0xFFFF) << 16);
if (t1 >= t3)
{
t1 = t3;
}
//loc_85EB8
a3 = t0 * t1;
a2 = VZ0;
a1 = a0 >> 16;
a0 &= 0xFFFF;
a3 >>= 12;
loc_85ED0:
int at = s5 - a3;
if (s4 - a3 < 0)
{
s6 = s5;
s5 = s4;
s4 = a3;
at = (int)s3;
s3 = s2;
s2 = s1;
s1 = (int*)at;
//j loc_85F2C
}
else if (s5 - a3 < 0)
{
//loc_85EFC
s6 = s5;
s5 = a3;
at = (int)s3;
s3 = s2;
s2 = (int*)at;
//j loc_85F2C
}
else if (s6 - a3 < 0)
{
//loc_85F1C
s6 = a3;
at = (int)s3;
}
else
{
goto loc_85F40;
}
loc_85F2C:///@TODO expand (implant) into ifs then let it all fall through.
t0 = ((int*)&gp->Type)[0];
((short*)at)[8] = a0;
((short*)at)[9] = a1;
((short*)at)[10] = a2;
((int*)at)[3] = t0;
}//loc_85F40
}
}
loc_85F40:
gp++;
goto loc_85D34;
}
}
//loc_85F48
int at = 4096;
if (s4 != 0 || s7 - 4096 != 0)
{
IR0 = s7;
IR1 = s4;
IR2 = s5;
IR3 = s6;
t0 = (at - s7) + 4096;
docop2(0x198003D);
t1 = SXY0;
t2 = SXY1;
int t3 = SXY2;
at = s4 < 4096 ? 1 : 0;
s4 = IR1;
s5 = IR2;
s6 = IR3;
IR1 = t1;
IR2 = t2;
IR3 = t3;
docop2(0x198003D);
t1 = IR1;
t2 = IR2;
t3 = IR3;
SXY0 = t1;
SXY1 = t2;
SXY2 = t3;
if (at == 0)
{
s4 = t0;
}
}
//loc_85FCC
fp = number_dynamics;
struct DYNAMIC* gpp = &dynamics[0];
loc_85FD4:
if (fp--)
{
t4 = gpp->x;
t5 = gpp->y;
t6 = gpp->z;
t4 -= t7;
t5 -= t8;
t6 -= t9;
IR1 = t4;
IR2 = t5;
IR3 = t6;
int a0 = t4;
if (t4 < 0)
{
a0 = -t4;
}
//loc_8600C
docop2(0xA00428);
int a1 = t5;
if (t5 < 0)
{
a1 = -t5;
}
//loc_8601C
int a2 = t6;
if (t6 < 0)
{
a2 = -t6;
}
//loc_86028
if ((unsigned)a0 < 0x2000 && (unsigned)a1 < 0x2000 && (unsigned)a2 < 0x2000)
{
t0 = ((int*)&gpp->falloff)[0] >> 1;
t1 = gpp->FalloffScale;
a0 = MAC1;
a1 = MAC2;
a2 = MAC3;
a0 += a1;
a0 += a2;
if (mSqrt_L(a0) < t0)
{
v0 = (v0 * t1) >> 8;
a0 = t4;
a1 = t5;
a2 = t6;
mNormaliseXYZ_L(&a0, &a1, &a2);
int a3 = 4096 - v0;
//at = s5 - a3
if (s4 - a3 < 0)
{
s6 = s5;
s5 = s4;
s4 = a3;
at = (int)s3;
s3 = s2;
s2 = s1;
s1 = (int*)at;
//goto loc_860EC;
}//loc_860BC
else if (s5 - a3 < 0)
{
s6 = s5;
s5 = a3;
at = (int)s3;
s3 = s2;
s2 = (int*)at;
//goto loc_860EC
}
else if (s6 - a3 < 0)
{
//loc_860DC
s6 = a3;
at = (int)s3;
}
else
{
goto loc_86108;
}
//loc_860EC
t0 = ((int*)&gpp->on)[0];
((short*)at)[8] = a0;
((short*)at)[9] = a1;
((short*)at)[10] = a2;
((int*)at)[3] = t0;
if (s7 != 0)
{
s7 = a3;
}
}//loc_86108
}
loc_86108:
gpp++;
goto loc_85FD4;
}//loc_86110
at = s4 - 4096;
int* t00 = &scratchPad[0];
if (at >= 0)
{
s4 = at;
}
//loc_86120
t00[0] = s4;
t00[1] = (int)s1;
t00[7] = s5;
t00[8] = (int)s2;
t00[14] = s6;
t00[15] = (int)s3;
int* s66 = t00;
s5 = (int)light;
int s11 = SXY0;
int s22 = SXY1;
int s33 = SXY2;
v0 = 3;
int v1 = light->Light[3].pad;
//loc_86154
if (v0 != 0)
{
s4 = s66[1];
IR0 = s66[0];
t0 = ((int*)s4)[3];
int t3 = ((int*)s5)[2];
int s0 = t0 & 0xFF;
t2 = t0 >> 20;
t1 = (t0 >> 12) & 0xFF0;
t0 >>= 4;
t0 &= 0xFF0;
IR1 = t0;
IR2 = t1;
IR3 = t2;
int t5 = t3 >> 12;
int t4 = t3 >> 4;
docop2(0x198003D);
v0--;
if (v1 == 0)
{
t3 = ((short*)s4)[8];
t4 = ((short*)s4)[9];
t5 = ((short*)s4)[10];
t0 = t3;
t1 = t4;
t2 = t5;
}
else
{
//loc_861BC
t3 <<= 4;
t3 &= 0xFF0;
t4 &= 0xFF0;
t5 &= 0xFF0;
RFC = t3;
GFC = t4;
BFC = t5;
IR0 = 3584;
t3 = ((short*)s4)[8];
docop2(0x980011);
t4 = ((short*)s4)[9];
t5 = ((short*)s4)[10];
((int*)s5)[0] = t0;
((short*)s5)[2] = t2;
t1 = t0 >> 16;
t0 <<= 16;
t0 >>= 16;
}
//loc_86204
((int*)s5)[2] = RGB2;
((int*)s66)[2] = IR1;
((int*)s66)[6] = IR2;
((int*)s66)[8] = IR3;
s11 = MAC1;
s22 = MAC2;
s33 = MAC3;
IR0 = 2048;
t3 -= t0;
t4 -= t1;
t5 -= t2;
docop2(0x1A8003E);
t3 >>= 3;
t4 >>= 3;
t5 >>= 3;
t0 += t3;
t1 += t4;
t2 += t5;
((short*)s66)[10] = t0;
((short*)s66)[11] = t1;
((short*)s66)[12] = t2;
t0 &= 0xFFFF;
t1 <<= 16;
t0 |= t1;
((int*)s5)[0] = t0;
((int*)s5)[1] = t2;
if (s0 != 0)
{
s11 = IR1;
s22 = IR2;
s33 = IR3;
}
//loc_86280
s66 += 7;
s5 += 0xC;
}
//loc_8628C
at = 0x1000000;
if (v1 != 0)
{
IR1 = ((int*)s5)[0];
IR2 = ((int*)s5)[1];
IR3 = ((int*)s5)[2];
RFC = s11;
GFC = s22;
BFC = s33;
IR0 = 1536;
docop2(0x980011);
s11 = IR1;
s22 = IR2;
s33 = IR3;
}//loc_862C8
((int*)s5)[0] = s11;
((int*)s5)[1] = s22;
((int*)s5)[2] = s33 | at;
s11 <<= 1;
s22 <<= 1;
s33 <<= 1;
RBK = s11;
GBK = s22;
BBK = s33;
int s00 = (R11 & 0xFFFF) | ((R12 << 16) & 0xFFFF);
s11 = (R13 & 0xFFFF) | ((R21 << 16) & 0xFFFF);
s22 = (R22 & 0xFFFF) | ((R23 << 16) & 0xFFFF);
s33 = (R31 & 0xFFFF) | ((R32 << 16) & 0xFFFF);
s4 = R33;
t0 = 0x808080;
if (s7 != 0 && s7 < 0xFFF)
{
s7 >>= 5;
t0 = s7 << 16;
t1 = s7 << 8;
t0 |= t1;
t0 |= s7;
}
//loc_86330
R = (t0 & 0xFF);
G = (t0 & 0xFF00) >> 8;
B = (t0 & 0xFF0000) >> 16;
CODE = (t0 & 0xFF000000) >> 24;
struct MATRIX3D* s55 = &CamGTE;
struct MATRIX3D* s666 = &LightPos;
int* s77 = &scratchPad[0];
t0 = ((int*)s55)[0];
t1 = ((int*)s55)[1];
t2 = ((int*)s55)[2];
t3 = ((int*)s55)[3];
t4 = ((int*)s55)[4];
R11 = t0 & 0xFFFF;
R12 = (t0 >> 16) & 0xFFFF;
R13 = t1 & 0xFFFF;
R21 = (t1 >> 16) & 0xFFFF;
R22 = t2 & 0xFFFF;
R23 = (t2 >> 16) & 0xFFFF;
R31 = t3 & 0xFFFF;
R32 = (t3 >> 16) & 0xFFFF;
R33 = t4;
VX0 = s77[5] & 0xFFFF;
VY0 = (s77[5] >> 16) & 0xFFFF;
VZ0 = s77[6] & 0xFFFF;
VX1 = s77[12] & 0xFFFF;
VY1 = (s77[12] >> 16) & 0xFFFF;
docop2(0x486012);
VZ1 = s77[13];
VX2 = s77[19] & 0xFFFF;
VY2 = (s77[19] >> 16) & 0xFFFF;
VZ2 = s77[20] & 0xFFFF;
t1 = ((unsigned short*)s77)[18];
t0 = ((unsigned short*)s77)[4];
t1 <<= 16;
t0 |= t1;
t2 = ((unsigned short*)s77)[6];
t5 = IR1;
t8 = IR2;
t9 = IR3;
docop2(0x48E012);
t1 = ((unsigned short*)s77)[32];
t2 <<= 16;
t1 |= t2;
t3 = ((unsigned short*)s77)[34];
t2 = ((unsigned short*)s77)[20];
t3 <<= 16;
t2 |= t3;
t4 = ((unsigned short*)s77)[22];
t9 = IR1;
t7 = IR2;
int a0 = IR3;
docop2(0x496012);
t3 = ((unsigned short*)s77)[8];
t4 <<= 16;
t3 |= t4;
t4 = ((unsigned short*)s77)[36];
t5 &= 0xFFFF;
t8 <<= 16;
t5 |= t8;
t6 &= 0xFFFF;
t9 <<= 16;
t6 |= t9;
t7 &= 0xFFFF;
a0 <<= 16;
t7 |= a0;
t8 = IR1;
a0 = IR2;
t9 = IR3;
t8 &= 0xFFFF;
a0 <<= 16;
t8 |= a0;
((int*)s666)[0] = t5;
((int*)s666)[1] = t6;
((int*)s666)[2] = t7;
((int*)s666)[3] = t8;
((int*)s666)[4] = t9;
SZ0 = t0;
SZ1 = t1;
SZ2 = t2;
SZ3 = t3;
RGB0 = t4;
R11 = s00 & 0xFFFF;
R12 = (s00 >> 16) & 0xFFFF;
R13 = s11 & 0xFFFF;
R21 = (s11 >> 16) & 0xFFFF;
R22 = s22 & 0xFFFF;
R23 = (s22 >> 16) & 0xFFFF;
R31 = s33 & 0xFFFF;
R32 = (s33 >> 16) & 0xFFFF;
RFC = 0;
GFC = 0;
BFC = 0;
}
[Specific-PSXPC_N] Correct S_CalculateLight.
#include "LIGHT.H"
#include "EFFECT2.H"
#include "DRAW.H"
#include "MATHS.H"
#include "LOAD_LEV.H"
#include "GTEREG.H"
#include "MISC.H"
#include "DRAWSPKS.H"
void mNormaliseXYZ_L(int* x, int* y, int* z)//86500 (F)
{
IR1 = *x;
IR2 = *y;
IR3 = *z;
int a3 = 0x1F;
docop2(0xA00428);
int v0 = MAC1;
int v1 = MAC2;
int at = MAC3;
v0 += v1;
v0 += at;
LZCR = gte_leadingzerocount(v0);
LZCS = v0;
IR1 = *x;
IR2 = *y;
v1 = LZCR;
at = -2;
v1 &= at;
a3 -= v1;
a3 >>= 1;
at = v1 - 24;
if (at >= 0)
{
v0 <<= at;
}
else
{
//loc_8655C
at = 24;
at -= v1;
v0 >>= at;
}
//loc_86568
v0 -= 64;
v0 = ScalarTable[v0];
IR3 = *z;
IR0 = v0;
docop2(0x190003D);
*x = MAC1;
*y = MAC2;
*z = MAC3;
*x >>= a3;
*y >>= a3;
*z >>= a3;
}
int mSqrt_L(int a0)//8649C (F)
{
LZCR = gte_leadingzerocount(a0);
LZCS = a0;
int v0 = 0x1F;
if (a0 != 0)
{
int v1 = LZCR;
int at = -2;
v1 &= at;
v0 -= v1;
v0 >>= 1;
at = v1 - 24;
if (at >= 0)
{
a0 <<= at;
}
else
{
at = 24;
at -= v1;
a0 >>= at;
}
//loc_864DC
a0 -= 64;
a0 = SqrtTable[a0];
a0 <<= v0;
}
//locret_864F8
return a0 >> 12;
}
void S_CalculateStaticMeshLight(long floor, long touch_bits, long mesh_bits, int anim_state)//8669C(<)
{
int t5 = 0;
int t4 = 0;
int t3 = 0;
int t7;
int t6;
int t0;
int a0;
int a1;
int a2;
int v1;
int at;
int v0;
int i;
if (number_dynamics > 0)
{
t7 = floor;
t6 = touch_bits;
t0 = mesh_bits;
//loc_866C4
for(i = 0; i < number_dynamics; i++)
{
IR1 = floor - dynamics[i].x;
//loc_866E4
if (ABS(IR1) < 0x2001)
{
IR2 = touch_bits - dynamics[i].y;
if (ABS(IR1) < 0x2001)
{
IR2 = mesh_bits - dynamics[i].z;
if (ABS(IR2) < 0x2001)
{
docop2(0xA00428);
a0 = MAC1;
a1 = MAC2;
a2 = MAC3;
a0 += a1;
a0 += a2;
a0 = gte_leadingzerocount(a0);
v0 = 0x1F;
if (a0 != 0)
{
v1 = LZCR;
at = -2;
v1 &= at;
v0 -= v1;
v0 >>= 1;
at = v1 - 0x18;
if (at >= 0)
{
a0 <<= at;
}//loc_86774
else
{
at = 0x18;
at -= v1;
a0 >>= at;
}
//loc_86780
a0 -= 0x40;
a0 = SqrtTable[a0];
a0 <<= v0;
}
//loc_8679C
v0 = a0 >> 12;
v1 = dynamics[i].falloff >> 1;
a0 = v0;
v0 = a0 << 13;
if (v1 >= a0)
{
v0 -= a0;
v0 = v0 / v1;
v1 = 0x1FFF;
a0 = dynamics[i].r;
v1 -= v0;
at = a0 * v1;
v0 = dynamics[i].g;
a0 = v0 * v1;
v0 = dynamics[i].b;
v1 = v0 * v1;
v0 = at >> 13;
t3 += v0;
v0 = a0 >> 13;
t4 += v0;
v0 = v1 >> 13;
t5 += v0;
}
}//loc_86810
}//loc_86810
}//loc_86810
}
}//loc_8681C
v0 = t3 + t4;
v0 += t5;
a0 = anim_state;
if (v0 != 0)
{
v0 = anim_state & 0x1F;
v0 <<= 3;
t3 += v0;
v1 = anim_state & 0x3E0;
v1 >>= 2;
t4 += v1;
v1 = anim_state & 0x7C00;
v1 >>= 7;
t5 += v1;
if (t3 >= 0x100)
{
t3 = 0xFF;
}//loc_86860
if (t4 >= 0x100)
{
t4 = 0xFF;
}//loc_8686C
if (t5 >= 0x100)
{
t5 = 0xFF;
}//loc_86878
t4 <<= 8;
t5 <<= 16;
a0 = t3 | t4 | t5;
}
else
{
//loc_8688C
v1 = a0 & 0x3E0;
v0 = a0 & 0x7C00;
a0 &= 0x1F;
a0 <<= 3;
v1 <<= 6;
v0 <<= 9;
a0 |= v1;
a0 |= v0;
}
R = (a0 & 0xFF);
G = (a0 & 0xFF00) >> 8;
B = (a0 & 0xFF0000) >> 16;
CODE = (a0 & 0xFF000000) >> 24;
}
void CalculateObjectLighting(struct ITEM_INFO* item/*a0*/, short* frmptr/*a1*/, struct STASHEDOBJ* sobject/*s0*/, short numnodestodraw/*s1*/)
{
if (item->shade < 0)
{
R11 = 4096;
R12 = 0;
R13 = 0;
R21 = 0;
R22 = 4096;
R23 = 0;
R31 = 0;
R32 = 0;
R33 = 4096;
TRX = 0;
TRY = 0;
TRZ = 0;
Matrix++;
mRotYXZ(item->pos.y_rot, item->pos.x_rot, item->pos.z_rot);
mTranslateXYZ((frmptr[0] + frmptr[1]) >> 1, (frmptr[2] + frmptr[4]) >> 1, (frmptr[3] + frmptr[5]) >> 1);
mPopMatrix();
//S_CalculateLight(item->pos.x_pos + TRX, item->pos.y_pos + TRY, item->pos.z_pos + TRZ, item->room_number, &item->il);
}
else
{
//loc_8668C
S_CalculateStaticMeshLight(item->pos.x_pos, item->pos.y_pos, item->pos.z_pos, 0x7FFF);
}
}
void S_CalculateLight(long x, long y, long z, short room_num, struct ITEM_LIGHT* light)
{
struct room_info* r;//$t0
int scratchPad[256];
int t3;
int t4;
int t5;
int t6;
S_MemSet((char*)&scratchPad[0], 0, 1024);
int* s1 = &scratchPad[21];
//at = 0x1000
s1[3] = 0;
s1[4] = 0;
((short*)s1)[10] = 0x1000;
int* s2 = &s1[8];
s2[3] = 0;
s2[4] = 0;
((short*)s2)[10] = 0x1000;
int* s3 = &s2[8];
s3[3] = 0;
s3[4] = 0;
((short*)s3)[10] = 0x1000;
int s4 = 0;
int s5 = 0;
int s6 = 0;
int s7 = 4096;
int t7 = x;
int t8 = y;
int t9 = z;
//t0 = &room[0];
//s0 = gp
r = &room[room_num];
struct LIGHTINFO* gp = r->light;
int v0 = ((int*)&r->ambient)[0];
unsigned short fp = r->num_lights;
int t2 = (v0 >> 12) & 0xFF0;
int t1 = (v0 >> 4) & 0xFF0;
int t0 = (v0 << 4) & 0xFF0;
SXY0 = t0;
SXY1 = t1;
SXY2 = t2;
loc_85D34:
if (fp-- != 0)
{
int t3 = gp->Type;
int t2 = ((int*)&gp->Inner)[0];
int t0 = t2 & 0xFF00;
if (gp->Type == 0)
{
s4 |= 0x2000;
int a0 = ((int*)&gp->nx)[0];
int a1 = ((int*)&gp->nz)[0];
int a2 = ((int*)&gp->Type)[0];
s1[4] = a0;
s1[5] = a1;
s1[3] = a2;
gp++;
goto loc_85D34;
}
else
{
//loc_85D70
t4 = gp->x;
t5 = gp->y;
t6 = gp->z;
t4 -= t7;
t5 -= t8;
t6 -= t9;
IR1 = t4;
IR2 = t5;
IR3 = t6;
t0 >>= 1;
docop2(0xA00428);
t1 = (t2 & 0xFF) << 7;
t2 >>= 16;
int a3 = t3 & 1;
int a0 = MAC1;
int a1 = MAC2;
int a2 = MAC3;
a0 += a1;
a0 += a2;
int v0 = mSqrt_L(a0);
a0 = t4;
if (v0 < t0)
{
a1 = t5;
a2 = t6;
if (a3 != 0)
{
t4 = v0;
mNormaliseXYZ_L(&a0, &a1, &a2);
t5 = gp->Intensity;
a3 = t5;
if (t4 >= t1)
{
t4 -= t1;
t5 = t0 - t1;
t5 -= t4;
a3 = (t5 * t2) >> 8;
}
//loc_85E0C
int at = 4096;
if (t3 - 3 == 0)
{
a3 = at - a3;
if (a3 < s7)
{
gp++;
s7 = a3;
}
goto loc_85D34;
}
goto loc_85ED0;
}
else
{
//loc_85E30
t4 = v0;
mNormaliseXYZ_L(&a0, &a1, &a2);
v0 = (R11 & 0xFFFF) | (R12 << 16) & 0xFFFF;
int v1 = (R13 & 0xFFFF) | (R21 << 16) & 0xFFFF;
VX0 = ((int*)&gp->nx)[0] & 0xFFFF;
VY0 = (((int*)&gp->nx)[0] >> 16) & 0xFFFF;
VZ0 = ((int*)&gp->nz)[0] & 0xFFFF;
a1 <<= 16;
a0 &= 0xFFFF;
a0 |= a1;
R11 = a0 & 0xFFFF;
R12 = (a0 >> 16) & 0xFFFF;
R13 = a2 & 0xFFFF;
R21 = (a2 >> 16) & 0xFFFF;
t3 = t4 - t1;
docop2(0x486012);
t5 = t0 - t1;
t5 -= t3;
t1 = t5 * t2;
t5 = ((int*)&gp->Length)[0];
t3 = ((unsigned short*)&gp->Intensity)[0];
t6 = t5 >> 16;
t0 = IR1;
R11 = v0 & 0xFFFF;
R12 = (v0 >> 16) & 0xFFFF;
R13 = v1 & 0xFFFF;
R21 = (v1 >> 16) & 0xFFFF;
t5 &= 0xFFFF;
if (t0 >= t6)
{
if (t0 >= t5)
{
t0 = 4096;
}
//loc_85EA4
t1 >>= 8;
a0 = (VX0 & 0xFFFF) | ((VY0 & 0xFFFF) << 16);
if (t1 >= t3)
{
t1 = t3;
}
//loc_85EB8
a3 = t0 * t1;
a2 = VZ0;
a1 = a0 >> 16;
a0 &= 0xFFFF;
a3 >>= 12;
loc_85ED0:
int at = s5 - a3;
if (s4 - a3 < 0)
{
s6 = s5;
s5 = s4;
s4 = a3;
at = (int)s3;
s3 = s2;
s2 = s1;
s1 = (int*)at;
//j loc_85F2C
}
else if (s5 - a3 < 0)
{
//loc_85EFC
s6 = s5;
s5 = a3;
at = (int)s3;
s3 = s2;
s2 = (int*)at;
//j loc_85F2C
}
else if (s6 - a3 < 0)
{
//loc_85F1C
s6 = a3;
at = (int)s3;
}
else
{
goto loc_85F40;
}
loc_85F2C:///@TODO expand (implant) into ifs then let it all fall through.
t0 = ((int*)&gp->Type)[0];
((short*)at)[8] = a0;
((short*)at)[9] = a1;
((short*)at)[10] = a2;
((int*)at)[3] = t0;
}//loc_85F40
}
}
loc_85F40:
gp++;
goto loc_85D34;
}
}
//loc_85F48
int at = 4096;
if (s4 != 0 || s7 - 4096 != 0)
{
IR0 = s7;
IR1 = s4;
IR2 = s5;
IR3 = s6;
t0 = (at - s7) + 4096;
docop2(0x198003D);
t1 = SXY0;
t2 = SXY1;
int t3 = SXY2;
at = s4 < 4096 ? 1 : 0;
s4 = IR1;
s5 = IR2;
s6 = IR3;
IR1 = t1;
IR2 = t2;
IR3 = t3;
docop2(0x198003D);
t1 = IR1;
t2 = IR2;
t3 = IR3;
SXY0 = t1;
SXY1 = t2;
SXY2 = t3;
if (at == 0)
{
s4 = t0;
}
}
//loc_85FCC
fp = number_dynamics;
struct DYNAMIC* gpp = &dynamics[0];
loc_85FD4:
if (fp--)
{
t4 = gpp->x;
t5 = gpp->y;
t6 = gpp->z;
t4 -= t7;
t5 -= t8;
t6 -= t9;
IR1 = t4;
IR2 = t5;
IR3 = t6;
int a0 = t4;
if (t4 < 0)
{
a0 = -t4;
}
//loc_8600C
docop2(0xA00428);
int a1 = t5;
if (t5 < 0)
{
a1 = -t5;
}
//loc_8601C
int a2 = t6;
if (t6 < 0)
{
a2 = -t6;
}
//loc_86028
if ((unsigned)a0 < 0x2000 && (unsigned)a1 < 0x2000 && (unsigned)a2 < 0x2000)
{
t0 = ((int*)&gpp->falloff)[0] >> 1;
t1 = gpp->FalloffScale;
a0 = MAC1;
a1 = MAC2;
a2 = MAC3;
a0 += a1;
a0 += a2;
if (mSqrt_L(a0) < t0)
{
v0 = (v0 * t1) >> 8;
a0 = t4;
a1 = t5;
a2 = t6;
mNormaliseXYZ_L(&a0, &a1, &a2);
int a3 = 4096 - v0;
//at = s5 - a3
if (s4 - a3 < 0)
{
s6 = s5;
s5 = s4;
s4 = a3;
at = (int)s3;
s3 = s2;
s2 = s1;
s1 = (int*)at;
//goto loc_860EC;
}//loc_860BC
else if (s5 - a3 < 0)
{
s6 = s5;
s5 = a3;
at = (int)s3;
s3 = s2;
s2 = (int*)at;
//goto loc_860EC
}
else if (s6 - a3 < 0)
{
//loc_860DC
s6 = a3;
at = (int)s3;
}
else
{
goto loc_86108;
}
//loc_860EC
t0 = ((int*)&gpp->on)[0];
((short*)at)[8] = a0;
((short*)at)[9] = a1;
((short*)at)[10] = a2;
((int*)at)[3] = t0;
if (s7 != 0)
{
s7 = a3;
}
}//loc_86108
}
loc_86108:
gpp++;
goto loc_85FD4;
}//loc_86110
at = s4 - 4096;
int* t00 = &scratchPad[0];
if (at >= 0)
{
s4 = at;
}
//loc_86120
t00[0] = s4;
t00[1] = (int)s1;
t00[7] = s5;
t00[8] = (int)s2;
t00[14] = s6;
t00[15] = (int)s3;
int* s66 = t00;
s5 = (int)light;
int s11 = SXY0;
int s22 = SXY1;
int s33 = SXY2;
v0 = 3;
int v1 = light->Light[3].pad;
//loc_86154
if (v0 != 0)
{
s4 = s66[1];
IR0 = s66[0];
t0 = ((int*)s4)[3];
int t3 = ((int*)s5)[2];
int s0 = t0 & 0xFF;
t2 = t0 >> 20;
t1 = (t0 >> 12) & 0xFF0;
t0 >>= 4;
t0 &= 0xFF0;
IR1 = t0;
IR2 = t1;
IR3 = t2;
int t5 = t3 >> 12;
int t4 = t3 >> 4;
docop2(0x198003D);
v0--;
if (v1 == 0)
{
t3 = ((short*)s4)[8];
t4 = ((short*)s4)[9];
t5 = ((short*)s4)[10];
t0 = t3;
t1 = t4;
t2 = t5;
}
else
{
//loc_861BC
t3 <<= 4;
t3 &= 0xFF0;
t4 &= 0xFF0;
t5 &= 0xFF0;
RFC = t3;
GFC = t4;
BFC = t5;
IR0 = 3584;
t3 = ((short*)s4)[8];
docop2(0x980011);
t4 = ((short*)s4)[9];
t5 = ((short*)s4)[10];
((int*)s5)[0] = t0;
((short*)s5)[2] = t2;
t1 = t0 >> 16;
t0 <<= 16;
t0 >>= 16;
}
//loc_86204
((int*)s5)[2] = RGB2;
((int*)s66)[2] = IR1;
((int*)s66)[3] = IR2;
((int*)s66)[4] = IR3;
s11 = MAC1;
s22 = MAC2;
s33 = MAC3;
IR0 = 2048;
t3 -= t0;
t4 -= t1;
t5 -= t2;
docop2(0x1A8003E);
t3 >>= 3;
t4 >>= 3;
t5 >>= 3;
t0 += t3;
t1 += t4;
t2 += t5;
((short*)s66)[10] = t0;
((short*)s66)[11] = t1;
((short*)s66)[12] = t2;
t0 &= 0xFFFF;
t1 <<= 16;
t0 |= t1;
((int*)s5)[0] = t0;
((int*)s5)[1] = t2;
if (s0 != 0)
{
s11 = IR1;
s22 = IR2;
s33 = IR3;
}
//loc_86280
s66 += 7;
s5 += 0xC;
}
//loc_8628C
at = 0x1000000;
if (v1 != 0)
{
IR1 = ((int*)s5)[0];
IR2 = ((int*)s5)[1];
IR3 = ((int*)s5)[2];
RFC = s11;
GFC = s22;
BFC = s33;
IR0 = 1536;
docop2(0x980011);
s11 = IR1;
s22 = IR2;
s33 = IR3;
}//loc_862C8
((int*)s5)[0] = s11;
((int*)s5)[1] = s22;
((int*)s5)[2] = s33 | at;
s11 <<= 1;
s22 <<= 1;
s33 <<= 1;
RBK = s11;
GBK = s22;
BBK = s33;
int s00 = (R11 & 0xFFFF) | ((R12 << 16) & 0xFFFF);
s11 = (R13 & 0xFFFF) | ((R21 << 16) & 0xFFFF);
s22 = (R22 & 0xFFFF) | ((R23 << 16) & 0xFFFF);
s33 = (R31 & 0xFFFF) | ((R32 << 16) & 0xFFFF);
s4 = R33;
t0 = 0x808080;
if (s7 != 0 && s7 < 0xFFF)
{
s7 >>= 5;
t0 = s7 << 16;
t1 = s7 << 8;
t0 |= t1;
t0 |= s7;
}
//loc_86330
R = (t0 & 0xFF);
G = (t0 & 0xFF00) >> 8;
B = (t0 & 0xFF0000) >> 16;
CODE = (t0 & 0xFF000000) >> 24;
struct MATRIX3D* s55 = &CamGTE;
struct MATRIX3D* s666 = &LightPos;
int* s77 = &scratchPad[0];
t0 = ((int*)s55)[0];
t1 = ((int*)s55)[1];
t2 = ((int*)s55)[2];
t3 = ((int*)s55)[3];
t4 = ((int*)s55)[4];
R11 = t0 & 0xFFFF;
R12 = (t0 >> 16) & 0xFFFF;
R13 = t1 & 0xFFFF;
R21 = (t1 >> 16) & 0xFFFF;
R22 = t2 & 0xFFFF;
R23 = (t2 >> 16) & 0xFFFF;
R31 = t3 & 0xFFFF;
R32 = (t3 >> 16) & 0xFFFF;
R33 = t4;
VX0 = s77[5] & 0xFFFF;
VY0 = (s77[5] >> 16) & 0xFFFF;
VZ0 = s77[6] & 0xFFFF;
VX1 = s77[12] & 0xFFFF;
VY1 = (s77[12] >> 16) & 0xFFFF;
docop2(0x486012);
VZ1 = s77[13];
VX2 = s77[19] & 0xFFFF;
VY2 = (s77[19] >> 16) & 0xFFFF;
VZ2 = s77[20] & 0xFFFF;
t1 = ((unsigned short*)s77)[18];
t0 = ((unsigned short*)s77)[4];
t1 <<= 16;
t0 |= t1;
t2 = ((unsigned short*)s77)[6];
t5 = IR1;
t8 = IR2;
t9 = IR3;
docop2(0x48E012);
t1 = ((unsigned short*)s77)[32];
t2 <<= 16;
t1 |= t2;
t3 = ((unsigned short*)s77)[34];
t2 = ((unsigned short*)s77)[20];
t3 <<= 16;
t2 |= t3;
t4 = ((unsigned short*)s77)[22];
t9 = IR1;
t7 = IR2;
int a0 = IR3;
docop2(0x496012);
t3 = ((unsigned short*)s77)[8];
t4 <<= 16;
t3 |= t4;
t4 = ((unsigned short*)s77)[36];
t5 &= 0xFFFF;
t8 <<= 16;
t5 |= t8;
t6 &= 0xFFFF;
t9 <<= 16;
t6 |= t9;
t7 &= 0xFFFF;
a0 <<= 16;
t7 |= a0;
t8 = IR1;
a0 = IR2;
t9 = IR3;
t8 &= 0xFFFF;
a0 <<= 16;
t8 |= a0;
((int*)s666)[0] = t5;
((int*)s666)[1] = t6;
((int*)s666)[2] = t7;
((int*)s666)[3] = t8;
((int*)s666)[4] = t9;
SZ0 = t0;
SZ1 = t1;
SZ2 = t2;
SZ3 = t3;
RGB0 = t4;
R11 = s00 & 0xFFFF;
R12 = (s00 >> 16) & 0xFFFF;
R13 = s11 & 0xFFFF;
R21 = (s11 >> 16) & 0xFFFF;
R22 = s22 & 0xFFFF;
R23 = (s22 >> 16) & 0xFFFF;
R31 = s33 & 0xFFFF;
R32 = (s33 >> 16) & 0xFFFF;
RFC = 0;
GFC = 0;
BFC = 0;
} |
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/*
$Log$
Revision 1.13 2001/04/23 23:12:41 morsch
Overlap in closing cone corrected (thanks to Ivana Hrivnacova)
Revision 1.12 2001/03/16 16:26:05 morsch
Put vacuum in beam-pipe not air.
Revision 1.11 2000/10/27 15:21:24 morsch
Shield composition after muon project leader meeting: 24/10/2000
- 1 cm recess in steel for station 3
- no heavy shielding between chambers for stations 1 and 2
Revision 1.10 2000/10/02 21:28:15 fca
Removal of useless dependecies via forward declarations
Revision 1.9 2000/09/12 17:00:45 morsch
Overlaps in YMO3 and YMO4 (side-effect from last update only) corrected.
Revision 1.8 2000/09/12 16:11:43 morsch
- Bug in volume YGO2 corrected: PCON started with twice the same z-value.
- Recesses for chambers added to outer Pb cone.
Revision 1.7 2000/06/15 09:40:31 morsch
Obsolete typedef keyword removed
Revision 1.6 2000/06/13 15:01:38 morsch
Make kind of heavy shielding material (Pb, NiCuW) dependent on presence of outer cone.
Revision 1.5 2000/06/12 19:40:00 morsch
New structure of beam pipe and heating jacket.
Optional outer Pb cone added. Not yet compatible with chamber inner radii.
Revision 1.4 2000/04/03 08:13:40 fca
Introduce extra scope for non ANSI compliant C++ compilers
Revision 1.3 2000/01/17 10:29:30 morsch
Overlap between Shield and Absorber due to limited numerical precision removed
by displacing the Shield by epsilon = 0.01 cm.
Revision 1.2 2000/01/13 11:27:51 morsch
Overlaps corrected: YCS3, YCS4; Inner radius YS21 corrected
Revision 1.1 2000/01/12 15:44:03 morsch
Standard version of SHIL
*/
///////////////////////////////////////////////////////////////////////////////
// //
// Muon Shield Class //
// This class contains a description of the muon shield //
// //
//Begin_Html
/*
<img src="picts/AliSHILClass.gif">
*/
//End_Html
// //
// //
///////////////////////////////////////////////////////////////////////////////
#include "AliSHILv0.h"
#include "AliRun.h"
#include "AliMC.h"
#include "AliConst.h"
ClassImp(AliSHILv0)
//_____________________________________________________________________________
AliSHILv0::AliSHILv0()
{
//
// Default constructor for muon shield
//
}
//_____________________________________________________________________________
AliSHILv0::AliSHILv0(const char *name, const char *title)
: AliSHIL(name,title)
{
//
// Standard constructor for muon shield
//
SetMarkerColor(7);
SetMarkerStyle(2);
SetMarkerSize(0.4);
// Pb cone not yet compatible with muon chamber inner radii
// Switched off by default
fPbCone=kTRUE;
}
//_____________________________________________________________________________
void AliSHILv0::CreateGeometry()
{
//
// Build muon shield geometry
//
//
//Begin_Html
/*
<img src="picts/AliSHILv0.gif">
*/
//End_Html
//Begin_Html
/*
<img src="picts/AliSHILv0Tree.gif">
*/
//End_Html
Float_t cpar[5], cpar0[5], tpar[3], par1[39], pars1[100], par2[27], par3[27],
par4[21], par0[45];
Float_t dz, dZ;
Int_t *idtmed = fIdtmed->GetArray()-1699;
#include "ABSOSHILConst.h"
#include "SHILConst.h"
enum {kC=1705, kAl=1708, kFe=1709, kCu=1710, kW=1711, kPb=1712,
kNiCuW=1720, kVacuum=1715, kAir=1714, kConcrete=1716,
kPolyCH2=1717, kSteel=1709, kInsulation=1713};
//
// Material of the rear part of the shield
Int_t iHeavy=kNiCuW;
if (fPbCone) iHeavy=kPb;
//
// Mother volume
//
Float_t dRear1=dRear;
Float_t zstart=zRear-dRear1;
par0[0] = 0.;
par0[1] = 360.;
par0[2] = 28.;
Float_t dl=(zvac12-zstart)/2.;
dz=zstart+dl;
//
// start
par0[3] = -dl;
par0[4] = 0.;
par0[5] = zstart * TMath::Tan(accMin);
// recess station 1
par0[6] = -dz+zch11;
par0[7] = 0.;
par0[8] = zch11 * TMath::Tan(accMin);
par0[9] = par0[6];
par0[10] = 0.;
par0[11] = 17.9;
par0[12] = -dz+zch12;
par0[13] = 0.;
par0[14] = 17.9;
par0[15] = par0[12];
par0[16] = 0.;
par0[17] = zch12 * TMath::Tan(accMin);
// recess station 2
par0[18] = -dz+zch21;
par0[19] = 0.;
par0[20] = zch21 * TMath::Tan(accMin);
par0[21] = -dz+zch21;
par0[22] = 0.;
par0[23] = 23.;
par0[24] = -dz+zch22;
par0[25] = 0.;
par0[26] = 23.;
par0[27] = -dz+zch22;
par0[28] = 0.;
par0[29] = zch22 * TMath::Tan(accMin);
//
par0[30] = -dz+zvac6;
par0[31] = 0.;
par0[32] = zvac6 * TMath::Tan(accMin);
// end of 2 deg cone
par0[33] = -dz+zConeE;
par0[34] = 0.;
par0[35] = 30.;
par0[36] = -dz+zch31;
par0[37] = 0.;
par0[38] = 30.;
par0[39] = -dz+zch31;
par0[40] = 0.;
par0[41] = 29.;
par0[42] = -dz+zch32;
par0[43] = 0.;
par0[44] = 29.;
// start of 1.6 deg cone
par0[45] = -dz+zch32;
par0[46] = 0.;
par0[47] = 30.+(zch32-zConeE)*TMath::Tan(thetaOpenPbO);
// recess station 4
par0[48] = -dz+zch41;
par0[49] = 0.;
par0[50] = 30.+(zch41-zConeE)*TMath::Tan(thetaOpenPbO);
par0[51] = -dz+zch41;
par0[52] = 0.;
par0[53] = 37.5;
par0[54] = -dz+zch42;
par0[55] = 0.;
par0[56] = 37.5;
par0[57] = -dz+zch42;
par0[58] = 0.;
par0[59] = 30.+(zch42-zConeE)*TMath::Tan(thetaOpenPbO);
// recess station 5
par0[60] = -dz+zch51;
par0[61] = 0.;
par0[62] = 30.+(zch51-zConeE)*TMath::Tan(thetaOpenPbO);
par0[63] = -dz+zch51;
par0[64] = 0.;
par0[65] = 37.5;
par0[66] = -dz+zch52;
par0[67] = 0.;
par0[68] = 37.5;
par0[69] = -dz+zch52;
par0[70] = 0.;
par0[71] = 30.+(zch52-zConeE)*TMath::Tan(thetaOpenPbO);
// end of cone
par0[72] = -dz+zvac10;
par0[73] = 0.;
par0[74] = 30.+(zvac10-zConeE)*TMath::Tan(thetaOpenPbO);
par0[75] = -dz+zvac10;
par0[76] = 0.;
par0[77] = R42;
par0[78] = -dz+zvac11;
par0[79] = 0.;
par0[80] = R42;
par0[81] = -dz+zvac11;
par0[82] = 0.;
par0[83] = R43;
par0[84] = -dz+zvac12;
par0[85] = 0.;
par0[86] = R43;
gMC->Gsvolu("YMOT", "PCON", idtmed[kVacuum], par0, 87);
dz=zstart+dl;
gMC->Gspos("YMOT", 1, "ALIC", 0., 0., dz, 0, "ONLY");
//
dZ=-dl;
//
// First section: bellows below and behind front absorber
//
//
par1[0] = 0.;
par1[1] = 360.;
par1[2] = 12.;
dl=(zvac4-zstart)/2.;
par1[3] = -dl;
par1[4] = rAbs+(zstart-zOpen) * TMath::Tan(thetaOpen1);
par1[5] = zstart * TMath::Tan(accMin);
par1[6] = -dl+zvac1-zstart;
par1[7] = rAbs+ (zvac1-zOpen) * TMath::Tan(thetaOpen1);
par1[8] = zvac1 * TMath::Tan(accMin);
par1[9] = par1[6]+dr11/2.;
par1[10] = par1[7]+dr11;
par1[11] = (zvac1+dr11/2.) * TMath::Tan(accMin);
par1[12] = -dl+dRear1;
par1[13] = par1[10];
par1[14] = zRear * TMath::Tan(accMin);
par1[15] = -dl+dRear1;
par1[16] = par1[10];
par1[17] = R11;
par1[18] = -dl+(zvac1+dr11+dB1-zstart);
par1[19] = par1[16];
par1[20] = R11;
par1[21] = par1[18]+dr12;
par1[22] = par1[19]+dr12;
par1[23] = R11;
par1[24] = par1[21]+dF1;
par1[25] = par1[22];
par1[26] = R11;
par1[27] = par1[24]+dr12;
par1[28] = par1[25]-dr12;
par1[29] = R11;
par1[30] = par1[27]+dB1;
par1[31] = par1[28];
par1[32] = R11;
par1[33] = par1[30]+dr13;
par1[34] = par1[31]-dr13;
par1[35] = R11;
par1[36] = -dl+zvac4-zstart;
par1[37] = par1[34];
par1[38] = R11;
Float_t r2 = par1[37];
Float_t rBox= par1[31]-0.1;
Float_t rc1 = par1[7];
gMC->Gsvolu("YGO1", "PCON", idtmed[kNiCuW], par1, 39);
Int_t i;
for (i=0; i<39; i++) pars1[i] = par1[i];
for (i=4; i<38; i+=3) pars1[i] = 0.;
gMC->Gsvolu("YMO1", "PCON", idtmed[kVacuum+40], pars1, 39);
gMC->Gspos("YGO1", 1, "YMO1", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO1", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
// Steel envelope
tpar[0]=R11-dRSteel2;
tpar[1]=R11;
tpar[2]=(zvac4-zvac3)/2.;
gMC->Gsvolu("YSE1", "TUBE", idtmed[kNiCuW], tpar, 3);
dz=dl-tpar[2];
gMC->Gspos("YSE1", 1, "YGO1", 0., 0., dz, 0, "ONLY");
//
// 1st section: vacuum system
//
//
// Bellow 1
//
tpar[0]=rB1;
tpar[1]=rB1+hB1;
tpar[2]=eB1/2.;
gMC->Gsvolu("YB11", "TUBE", idtmed[kSteel+40], tpar, 3);
Float_t dl1=tpar[2];
tpar[0]=rB1+hB1-eB1;
tpar[1]=rB1+hB1;
tpar[2]=(lB1/2.-2.*eB1)/2.;
gMC->Gsvolu("YB12", "TUBE", idtmed[kSteel+40], tpar, 3);
Float_t dl2=tpar[2];
tpar[0]=rB1-eB1;
tpar[1]=rB1;
tpar[2]=lB1/8.;
gMC->Gsvolu("YB13", "TUBE", idtmed[kSteel+40], tpar, 3);
Float_t dl3=tpar[2];
tpar[0]=0;
tpar[1]=rB1+hB1;
tpar[2]=lB1/2.;
gMC->Gsvolu("YBU1", "TUBE", idtmed[kVacuum+40], tpar, 3);
dz=-tpar[2]+dl3;
gMC->Gspos("YB13", 1, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl3;
dz+=dl1;
gMC->Gspos("YB11", 1, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl2;
gMC->Gspos("YB12", 1, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl2;
dz+=dl1;
gMC->Gspos("YB11", 2, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl3;
gMC->Gspos("YB13", 2, "YBU1", 0., 0., dz, 0, "ONLY");
tpar[0]=0;
tpar[1]=rB1+hB1+0.5;
tpar[2]=10.*lB1/2.;
gMC->Gsvolu("YBM1", "TUBE", idtmed[kVacuum+40], tpar, 3);
Float_t bsize = tpar[2];
tpar[0]=rB1+hB1;
gMC->Gsvolu("YBI1", "TUBE", idtmed[kInsulation+40], tpar, 3);
gMC->Gspos("YBI1", 2, "YBM1", 0., 0., 0., 0, "ONLY");
dz=-bsize+lB1/2.;
for (i=0; i<10; i++) {
gMC->Gspos("YBU1", i+1 , "YBM1", 0., 0., dz, 0, "ONLY");
dz+=lB1;
}
dz=-dl+(zvac1-zstart)+dr11+bsize;
gMC->Gspos("YBM1", 1, "YMO1", 0., 0., dz, 0, "ONLY");
dz=dl-dr13-(zvac4-zvac3)-bsize;
gMC->Gspos("YBM1", 2, "YMO1", 0., 0., dz, 0, "ONLY");
//
// Flange
tpar[0]=0;
tpar[1]=rF1+0.6;
tpar[2]=dF1/2.;
gMC->Gsvolu("YFM1", "TUBE", idtmed[kVacuum+40], tpar, 3);
// Steel
tpar[0]=rB1;
tpar[1]=rF1+0.6;
tpar[2]=dF1/2.;
gMC->Gsvolu("YF11", "TUBE", idtmed[kSteel+40], tpar, 3);
// Insulation
tpar[0]=rF1;
tpar[1]=rF1+0.5;
tpar[2]=dF1/2.;
gMC->Gsvolu("YF12", "TUBE", idtmed[kInsulation+40], tpar, 3);
gMC->Gspos("YF11", 1, "YFM1", 0., 0., 0., 0, "ONLY");
gMC->Gspos("YF12", 1, "YFM1", 0., 0., 0., 0, "ONLY");
dz=-dl+(zvac2-zstart);
gMC->Gspos("YFM1", 2, "YMO1", 0., 0., dz, 0, "ONLY");
//
// pipe between flange and bellows
//
// Steel
tpar[0]=rB1-dTubeS;
tpar[1]=rB1+0.6;
tpar[2]=2.*(dB1+dr12-10.*lB1)/4.;
gMC->Gsvolu("YPF1", "TUBE", idtmed[kSteel+40], tpar, 3);
// Insulation
tpar[0]=rB1;
tpar[1]=rB1+0.5;
gMC->Gsvolu("YPS1", "TUBE", idtmed[kInsulation+40], tpar, 3);
gMC->Gspos("YPS1", 1, "YPF1", 0., 0., 0., 0, "ONLY");
dz=-dl+(zvac2-zstart)-dF1/2.-tpar[2];
gMC->Gspos("YPF1", 1, "YMO1", 0., 0., dz, 0, "ONLY");
dz=-dl+(zvac2-zstart)+dF1/2.+tpar[2];
gMC->Gspos("YPF1", 2, "YMO1", 0., 0., dz, 0, "ONLY");
// Pipe+Heating 1.5 mm
// Heating Jacket 5.0 mm
// Protection 1.0 mm
// ========================
// 7.5 mm
// pipe and heating jackets outside bellows
//
// left side
cpar0[0]=(zvac1+dr11-zstart)/2;
cpar0[1]=rVacu-0.05 +(zstart-zOpen)*TMath::Tan(thetaOpen1);
cpar0[2]=rVacu+0.7 +(zstart-zOpen)*TMath::Tan(thetaOpen1);
cpar0[3]=cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpen1);
cpar0[4]=cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpen1);
gMC->Gsvolu("YV11", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
dTubeS=0.15;
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+0.15;
cpar[2]=cpar0[1]+0.65;
cpar[3]=cpar0[3]+0.15;
cpar[4]=cpar0[3]+0.65;
gMC->Gsvolu("YI11", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI11", 1, "YV11", 0., 0., 0., 0, "ONLY");
dz=-dl+cpar0[0];
gMC->Gspos("YV11", 1, "YMO1", 0., 0., dz, 0, "ONLY");
// right side
dTubeS = 0.35;
dVacuS += 0.25;
cpar0[0] = (zvac4-zvac3)/2;
cpar0[1] = rB1;
cpar0[2] = cpar0[1]+dVacuS;
cpar0[3] = cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
cpar0[4] = cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
gMC->Gsvolu("YV12", "CONE", idtmed[kSteel], cpar0, 5);
Float_t r2V=cpar0[3];
//
// insulation
cpar[0] = cpar0[0];
cpar[1] = cpar0[1]+dTubeS;
cpar[2] = cpar0[1]+dTubeS+dInsuS;
cpar[3] = cpar0[3]+dTubeS;
cpar[4] = cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI12", "CONE", idtmed[kInsulation], cpar, 5);
gMC->Gspos("YI12", 1, "YV12", 0., 0., 0., 0, "ONLY");
dz=dl-cpar0[0];
gMC->Gspos("YV12", 1, "YMO1", 0., 0., dz, 0, "ONLY");
//
// Second Section
// Between first and second bellow section
//
par2[0] = 0.;
par2[1] = 360.;
par2[2] = 11.;
dl=(zvac7-zvac4)/2.;
// recess station 2
par2[3] = -dl;
par2[4] = r2;
par2[5] = R21;
par2[6] = -dl+.1;
par2[7] = r2;
par2[8] = R21;
par2[9] = -dl+(zvac6-zvac4);
par2[10] = r2+(zvac6-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[11] = R21;
par2[12] = -dl+(zvac6-zvac4);
par2[13] = par2[10];
par2[14] = zvac6*TMath::Tan(accMin);
// Start of Pb section
par2[15] = -dl+(zPb-zvac4);
par2[16] = r2+(zPb-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[17] = zPb*TMath::Tan(accMin);
//
// end of cone following 2 deg line
par2[18] = -dl+(zConeE-zvac4);
par2[19] = r2+(zConeE-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[20] = 30.;
// recess station 3
par2[21] = -dl+(zch31-zvac4);
par2[22] = r2+(zch31-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[23] = 30.;
par2[24] = -dl+(zch31-zvac4);
par2[25] = r2+(zch31-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[26] = 29.;
par2[27] = -dl+(zch32-zvac4);
par2[28] = r2+(zch32-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[29] = 29.;
par2[30] = -dl+(zch32-zvac4);
par2[31] = r2+(zch32-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[32] = 30.;
par2[33] = -dl+(zvac7-zvac4);
par2[34] = r2+(zvac7-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[35] = 30.;
gMC->Gsvolu("YGO2", "PCON", idtmed[kSteel+40], par2, 36);
//
// Lead cone
//
Float_t parPb[12];
parPb[0] = 0.;
parPb[1] = 360.;
parPb[2] = 3.;
Float_t dlPb=(zvac7-zPb)/2.;
parPb[3] = -dlPb;
parPb[4] = r2+(zPb-zvac4-10.) * TMath::Tan(thetaOpen2);
parPb[5] = zPb*TMath::Tan(accMin)-dRSteel2;
parPb[6] = -dlPb+(zConeE-zPb);
parPb[7] = r2+(zConeE-zvac4-10.) * TMath::Tan(thetaOpen2);
parPb[8] = 26.;
parPb[9] = dlPb;
parPb[10] = r2+(zvac7-zvac4-10.) * TMath::Tan(thetaOpen2);
parPb[11] = 26.;
gMC->Gsvolu("YXO2", "PCON", idtmed[kPb], parPb, 12);
gMC->Gspos("YXO2", 1, "YGO2", 0., 0., (zPb-zvac4)/2., 0, "ONLY");
//
// W cone
//
Float_t parW[15];
parW[0] = 0.;
parW[1] = 360.;
parW[2] = 4.;
Float_t dlW=(zPb-zvac4)/2.;
parW[3] = -dlW;
parW[4] = r2;
parW[5] = R21-dRSteel2;
parW[6] = -dlW+(zvac6-zvac4)+dRSteel2;
parW[7] = r2+(zvac6-zvac4+dRSteel2) * TMath::Tan(thetaOpen2);
parW[8] = R21-dRSteel2;
parW[9] = -dlW+(zvac6-zvac4)+dRSteel2;
parW[10] = r2+(zvac6-zvac4+dRSteel2) * TMath::Tan(thetaOpen2);
parW[11] = (zvac6+dRSteel2)*TMath::Tan(accMin)-dRSteel2;
parW[12] = dlW;
parW[13] = r2+(zPb-zvac4) * TMath::Tan(thetaOpen2);
parW[14] = zPb*TMath::Tan(accMin)-dRSteel2;
gMC->Gsvolu("YYO2", "PCON", idtmed[kNiCuW], parW, 15);
gMC->Gspos("YYO2", 1, "YGO2", 0., 0., -(zvac7-zPb)/2., 0, "ONLY");
for (i=4; i<35; i+=3) par2[i] = 0;
gMC->Gsvolu("YMO2", "PCON", idtmed[kVacuum+40], par2, 36);
gMC->Gspos("YGO2", 1, "YMO2", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO2", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
//
// 2nd section: vacuum system
//
cpar0[0]=(zvac7-zvac4)/2;
cpar0[1]=r2V;
cpar0[2]=r2V+dVacuS;
cpar0[3]=cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
cpar0[4]=cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
gMC->Gsvolu("YV21", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+dTubeS;
cpar[2]=cpar0[1]+dTubeS+dInsuS;
cpar[3]=cpar0[3]+dTubeS;
cpar[4]=cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI21", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI21", 1, "YV21", 0., 0., 0., 0, "ONLY");
gMC->Gspos("YV21", 1, "YMO2", 0., 0., 0., 0, "ONLY");
//
// Third Section: Bellows and Flange
//
par3[0] = 0.;
par3[1] = 360.;
par3[2] = 8.;
dl=(zvac9-zvac7)/2.;
par3[3] = -dl;
par3[4] = r2+(zvac7-zvac3) * TMath::Tan(thetaOpen2);
par3[5] = 30.;
par3[6] = -dl+dr21;
par3[7] = par3[4]+dr21;
par3[8] = 30.;
par3[9] = par3[6]+dB2;
par3[10] = par3[7];
par3[11] = 30.;
par3[12] = par3[9]+dr22;
par3[13] = par3[10]+dr22;
par3[14] = 30.;
par3[15] = par3[12]+dF2;
par3[16] = par3[13];
par3[17] = 30.;
par3[18] = par3[15]+dr22;
par3[19] = par3[16]-dr22;
par3[20] = 30.;
par3[21] = par3[18]+dB2;
par3[22] = par3[19];
par3[23] = 30.;
par3[24] = par3[21]+dr23;
par3[25] = par3[22];
par3[26] = 30.;
//
rBox=par3[22]-0.1;
Float_t r3=par3[25];
gMC->Gsvolu("YGO3", "PCON", idtmed[iHeavy+40], par3, 27);
for (i=4; i<26; i+=3) par3[i] = 0;
gMC->Gsvolu("YMO3", "PCON", idtmed[kVacuum+40], par3, 27);
gMC->Gspos("YGO3", 1, "YMO3", 0., 0., 0., 0, "ONLY");
//
// Steel envelope
tpar[0]=26;
tpar[1]=30;
tpar[2]=dl;
gMC->Gsvolu("YS31", "TUBE", idtmed[kSteel], tpar, 3);
gMC->Gspos("YS31", 1, "YGO3", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO3", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
// 3rd section: vacuum system
//
//
// Bellow2
//
tpar[0]=rB2;
tpar[1]=rB2+hB2;
tpar[2]=eB2/2.;
gMC->Gsvolu("YB21", "TUBE", idtmed[kSteel+40], tpar, 3);
dl1=tpar[2];
tpar[0]=rB2+hB2-eB2;
tpar[1]=rB2+hB2;
tpar[2]=(lB2/2.-2.*eB2)/2.;
gMC->Gsvolu("YB22", "TUBE", idtmed[kSteel+40], tpar, 3);
dl2=tpar[2];
tpar[0]=rB2-eB2;
tpar[1]=rB2;
tpar[2]=lB2/8.;
gMC->Gsvolu("YB23", "TUBE", idtmed[kSteel+40], tpar, 3);
dl3=tpar[2];
tpar[0]=0;
tpar[1]=rB2+hB2;
tpar[2]=lB2/2.;
gMC->Gsvolu("YBU2", "TUBE", idtmed[kVacuum+40], tpar, 3);
dz=-tpar[2]+dl3;
gMC->Gspos("YB23", 1, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl3;
dz+=dl1;
gMC->Gspos("YB21", 1, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl2;
gMC->Gspos("YB22", 1, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl2;
dz+=dl1;
gMC->Gspos("YB21", 2, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl3;
gMC->Gspos("YB23", 2, "YBU2", 0., 0., dz, 0, "ONLY");
tpar[0]=0;
tpar[1]=rB2+hB2;
tpar[2]=7.*lB2/2.;
gMC->Gsvolu("YBM2", "TUBE", idtmed[kVacuum+40], tpar, 3);
dz=-tpar[2]+lB2/2.;
for (i=0; i<7; i++) {
gMC->Gspos("YBU2", i+1 , "YBM2", 0., 0.,dz , 0, "ONLY");
dz+=lB2;
}
dz=-dl+dr21+tpar[2];
gMC->Gspos("YBM2", 1, "YMO3", 0., 0., dz, 0, "ONLY");
dz=dl-dr23-tpar[2];
gMC->Gspos("YBM2", 2, "YMO3", 0., 0., dz, 0, "ONLY");
//
// Flange
tpar[0]=0;
tpar[1]=rF2;
tpar[2]=dF2/2.;
gMC->Gsvolu("YFM2", "TUBE", idtmed[kVacuum+40], tpar, 3);
tpar[0]=rF2-2.;
tpar[1]=rF2;
tpar[2]=dF2/2.;
gMC->Gsvolu("YF21", "TUBE", idtmed[kSteel+40], tpar, 3);
gMC->Gspos("YF21", 1, "YFM2", 0., 0., 0., 0, "ONLY");
tpar[0]=rB2;
tpar[1]=rF2-2.;
tpar[2]=dFlange/2.;
gMC->Gsvolu("YF22", "TUBE", idtmed[kSteel+40], tpar, 3);
dz=-dF2/2.+tpar[2];
gMC->Gspos("YF22", 1, "YFM2", 0., 0., dz, 0, "ONLY");
dz= dF2/2.-tpar[2];
gMC->Gspos("YF22", 2, "YFM2", 0., 0., dz, 0, "ONLY");
dz=dr21/2.-dr23/2.;
gMC->Gspos("YFM2", 2, "YMO3", 0., 0., dz, 0, "ONLY");
//
// pipe between flange and bellows
tpar[0]=rB2-dTubeS;
tpar[1]=rB2;
tpar[2]=2.*(dB2+dr22-7.*lB2)/4.;
gMC->Gsvolu("YPF2", "TUBE", idtmed[kSteel+40], tpar, 3);
dz=dr21/2.-dr23/2.-dF2/2.-tpar[2];
gMC->Gspos("YPF2", 1, "YMO3", 0., 0., dz, 0, "ONLY");
dz=dr21/2.-dr23/2.+dF2/2.+tpar[2];
gMC->Gspos("YPF2", 2, "YMO3", 0., 0., dz, 0, "ONLY");
Float_t dHorZ=20.;
//
// 4th section: rear shield and closing cone
//
par4[0] = 0.;
par4[1] = 360.;
par4[2] = 7.;
dl=(zvac12-zvac9)/2.;
par4[3] = -dl;
par4[4] = r3;
par4[5] = 30.;
par4[6] = -dl+dHorZ;
par4[7] = r3;
par4[8] = 30.;
par4[9] = -dl+(zvac10-zvac9);
par4[10] = r3+(zvac10-zvac9-dHorZ) * TMath::Tan(thetaOpen3);
par4[11] = 30.;
par4[12] = par4[9];
par4[13] = par4[10];
par4[14] = R42;
par4[15] = -dl+(zvac11-zvac9);
par4[16] = r3+(zvac11-zvac9-dHorZ) * TMath::Tan(thetaOpen3);
par4[17] = R42;
par4[18] = par4[15];
par4[19] = par4[16];
par4[20] = R43;
par4[21] = -dl+(zvac12-zvac9);
par4[22] = rVacu+dVacuS;
par4[23] = R43;
gMC->Gsvolu("YGO4", "PCON", idtmed[iHeavy+40], par4, 24);
parPb[0] = (zvac12-zvac10)/2.;
parPb[1] = parPb[3];
parPb[2] = 31.;
parPb[3] = parPb[1]+2.*parPb[0]*TMath::Tan(thetaOpenPb);
parPb[4] = 31.;
gMC->Gsvolu("YXO5", "CONE", idtmed[kPb], parPb, 5);
gMC->Gspos("YXO5", 1, "YGO4", 0., 0., -dl+(zvac10-zvac9)+parPb[0], 0, "ONLY");
for (i=4; i<23; i+=3) par4[i] = 0;
gMC->Gsvolu("YMO4", "PCON", idtmed[kVacuum+40], par4, 24);
gMC->Gspos("YGO4", 1, "YMO4", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO4", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
// Closing concrete cone
//
cpar[0]=(zvac12-zvac11)/2.;
cpar[1] = r3+(zvac11-zvac9-dHorZ) * TMath::Tan(thetaOpen3);
cpar[2] = cpar[1]+0.001;
cpar[3] = rVacu+dVacuS;
cpar[4] = cpar[2];
gMC->Gsvolu("YCC4", "CONE", idtmed[kConcrete+40], cpar, 5);
dz=dl-cpar[0];
gMC->Gspos("YCC4", 1, "YGO4", 0., 0., dz, 0, "ONLY");
//
// Steel envelope
//
dz=-dl;
tpar[0]=26.;
tpar[1]=30.;
tpar[2]=(zvac10-zvac9)/2.;
gMC->Gsvolu("YS41", "TUBE", idtmed[kSteel], tpar, 3);
dz+=tpar[2];
gMC->Gspos("YS41", 1, "YGO4", 0., 0., dz, 0, "ONLY");
dz+=tpar[2];
tpar[0]=R41-dRSteel2;
tpar[1]=R41;
tpar[2]=(zvac11-zvac10)/2.;
gMC->Gsvolu("YS43", "TUBE", idtmed[kPb], tpar, 3);
dz+=tpar[2];
gMC->Gspos("YS43", 1, "YGO4", 0., 0., dz, 0, "ONLY");
//
// rear lead shield
//
tpar[0]=R41;
tpar[1]=R42;
tpar[2]=(zvac11-zvac10)/2.;
gMC->Gsvolu("YPBI", "TUBE", idtmed[kPb+40], tpar, 3);
dz-=0;
gMC->Gspos("YPBI", 1, "YGO4", 0., 0., dz, 0, "ONLY");
tpar[0]=R42-5;
tpar[1]=R42;
tpar[2]=(zvac11-zvac10)/2.;
gMC->Gsvolu("YPBO", "TUBE", idtmed[kPb], tpar, 3);
gMC->Gspos("YPBO", 1, "YPBI", 0., 0., 0., 0, "ONLY");
//
// rear Fe shield
//
tpar[0]=31.;
tpar[1]=R43;
tpar[2]=(zvac12-zvac11)/2.;
gMC->Gsvolu("YFEI", "TUBE", idtmed[kFe+40], tpar, 3);
dz=dl-tpar[2];
gMC->Gspos("YFEI", 1, "YGO4", 0., 0., dz, 0, "ONLY");
tpar[0]=31.;
tpar[1]=R43;
tpar[2]=2.5;
gMC->Gsvolu("YFEO", "TUBE", idtmed[kFe], tpar, 3);
dz=-(zvac12-zvac11)/2.+tpar[2];
gMC->Gspos("YFEO", 1, "YFEI", 0., 0., dz, 0, "ONLY");
//
// Magnet element
//
tpar[0]=0.;
tpar[1]=R43;
tpar[2]=50.;
gMC->Gsvolu("YAEM", "TUBE", idtmed[kAir], tpar, 3);
tpar[0]=rAbs;
tpar[1]=R43;
tpar[2]=50.;
gMC->Gsvolu("YFEM", "TUBE", idtmed[kFe], tpar, 3);
gMC->Gspos("YFEM", 1, "YAEM", 0., 0., 0., 0, "ONLY");
//
dz=zvac12+50.;
gMC->Gspos("YAEM", 1, "ALIC", 0., 0., dz, 0, "ONLY");
//
//
// 4th section: vacuum system
//
// up to closing cone
Float_t r3V=r3-dr23+dVacuS-1.6;
cpar0[0]=(zvac11-zvac9)/2;
cpar0[1]=r3V-dVacuS;
cpar0[2]=r3V;
cpar0[3]=cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpen3);
cpar0[4]=cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpen3);
gMC->Gsvolu("YV31", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+dTubeS;
cpar[2]=cpar0[1]+dTubeS+dInsuS;
cpar[3]=cpar0[3]+dTubeS;
cpar[4]=cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI31", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI31", 1, "YV31", 0., 0., 0., 0, "ONLY");
dz=-dl+cpar[0];
gMC->Gspos("YV31", 1, "YMO4", 0., 0., dz, 0, "ONLY");
//
// closing cone
cpar0[0]=(zvac12-zvac11)/2;
cpar0[1]=r3V-dVacuS+(zvac11-zvac9)*TMath::Tan(thetaOpen3);
cpar0[2]=r3V +(zvac11-zvac9)*TMath::Tan(thetaOpen3);
cpar0[3]=rVacu;
cpar0[4]=rVacu+dTubeS+dInsuS+dProtS+dFreeS;
gMC->Gsvolu("YV32", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+dTubeS;
cpar[2]=cpar0[1]+dTubeS+dInsuS;
cpar[3]=cpar0[3]+dTubeS;
cpar[4]=cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI32", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI32", 1, "YV32", 0., 0., 0., 0, "ONLY");
//
// clearance
cpar[1]=cpar0[2]-dProtS-dFreeS;
cpar[2]=cpar0[2]-dProtS;
cpar[3]=cpar0[4]-dProtS-dFreeS;
cpar[4]=cpar0[4]-dProtS;
gMC->Gsvolu("YP32", "CONE", idtmed[kVacuum+40], cpar, 5);
gMC->Gspos("YP32", 1, "YV32", 0., 0., 0., 0, "ONLY");
dz=dl-cpar[0];
gMC->Gspos("YV32", 1, "YMO4", 0., 0., dz, 0, "ONLY");
//
//
// MUON trigger wall
//
tpar[0] = 50.;
tpar[1] = 310.;
tpar[2] = (zFilterOut - zFilterIn) / 2.;
gMC->Gsvolu("YFIM", "TUBE", idtmed[kFe+40], tpar, 3);
dz = (zFilterIn + zFilterOut) / 2.;
tpar[2] -= 10.;
gMC->Gsvolu("YFII","TUBE", idtmed[kFe], tpar, 3);
gMC->Gspos("YFII", 1, "YFIM", 0., 0., 0., 0, "ONLY");
gMC->Gspos("YFIM", 1, "ALIC", 0., 0., dz, 0, "ONLY");
//
// Shielding close to chamber
//
//
cpar[0]=(zch11-zRear)/2.;
cpar[1]=R11;
cpar[2]=zRear*TMath::Tan(accMin);
cpar[3]=R11;
cpar[4]=(zRear+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS1", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zRear-zstart)+cpar[0];
gMC->Gspos("YCS1", 1, "YMOT", 0., 0., dz, 0, "ONLY");
cpar[0]=(zvac4-zch12)/2.;
cpar[1]=R11;
cpar[2]=zch12*TMath::Tan(accMin);
cpar[3]=R11;
cpar[4]=(zch12+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS3", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch12-zstart)+cpar[0];
gMC->Gspos("YCS3", 1, "YMOT", 0., 0., dz, 0, "ONLY");
// Recess station 1
cpar[0]=(zch12-zch11)/2.;
cpar[1]=R11;
cpar[2]=18.;
cpar[3]=R11;
cpar[4]=17.9;
gMC->Gsvolu("YCS2", "CONE", idtmed[kAir], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch11-zstart)+cpar[0];
gMC->Gspos("YCS2", 1, "YMOT", 0., 0., dz, 0, "ONLY");
Float_t ptubs[5];
ptubs[0] = R11;
ptubs[1] = 17.9;
ptubs[2] = 0.;
// phi_min, phi_max
ptubs[3] = 0.;
ptubs[4] = 90.;
gMC->Gsvolu("YCR0", "TUBS", idtmed[kNiCuW], ptubs, 0);
Int_t idrotm[1799];
AliMatrix(idrotm[1701],90., 0., 90., 90., 0., 0.);
AliMatrix(idrotm[1702],90., 90., 90., 180., 0., 0.);
AliMatrix(idrotm[1703],90., 180., 90., 270., 0., 0.);
AliMatrix(idrotm[1704],90., 270., 90., 0., 0., 0.);
// Int_t ipos;
dz=-cpar[0];
// 1.
ptubs[2]=6.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 1, "YCS2", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 2, "YCS2", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 2.
ptubs[2]=5.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 3, "YCS2", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 4, "YCS2", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 3.
ptubs[2]=5.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 5, "YCS2", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 6, "YCS2", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 4.
ptubs[2]=6.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 7, "YCS2", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 8, "YCS2", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
cpar[0]=(zch21-zvac4)/2.;
cpar[1]=R21;
cpar[2]=zvac4*TMath::Tan(accMin);
cpar[3]=R21;
cpar[4]=(zvac4+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS4", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zvac4-zstart)+cpar[0];
gMC->Gspos("YCS4", 1, "YMOT", 0., 0., dz, 0, "ONLY");
cpar[0]=(zvac6-zch22)/2.;
cpar[1]=R21;
cpar[2]=zch22*TMath::Tan(accMin);
cpar[3]=R21;
cpar[4]=(zch22+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS6", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch22-zstart)+cpar[0];
gMC->Gspos("YCS6", 1, "YMOT", 0., 0., dz, 0, "ONLY");
// Recess station 2
cpar[0]=(zch22-zch21)/2.;
cpar[1]=R21;
cpar[2]=23.;
cpar[3]=R21;
cpar[4]=23.;
gMC->Gsvolu("YCS5", "CONE", idtmed[kAir], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch21-zstart)+cpar[0];
gMC->Gspos("YCS5", 1, "YMOT", 0., 0., dz, 0, "ONLY");
ptubs[0] = R21;
ptubs[1] = 23;
ptubs[2] = 0.;
ptubs[3] = 0.;
ptubs[4] = 90.;
gMC->Gsvolu("YCR1", "TUBS", idtmed[kNiCuW], ptubs, 0);
dz=-cpar[0];
// 1.
ptubs[2]=7.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 1, "YCS5", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 2, "YCS5", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 2.
ptubs[2]=6.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 3, "YCS5", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 4, "YCS5", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 3.
ptubs[2]=6.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 5, "YCS5", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 6, "YCS5", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 4.
ptubs[2]=7.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 7, "YCS5", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 8, "YCS5", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
//
// Outer Pb Cone
if (fPbCone) {
dl = (zvac10-zch32)/2.;
dz = dl+zch32;
par0[0] = 0.;
par0[1] = 360.;
par0[2] = 10.;
par0[ 3] = -dl;
par0[ 4] = 30.;
par0[ 5] = 30.+(zch32-zConeE)*TMath::Tan(thetaOpenPbO);
// 4th station
par0[ 6] = -dz + zch41;
par0[ 7] = 30.;
par0[ 8] = 30.+(zch41-zConeE)*TMath::Tan(thetaOpenPbO);
par0[ 9] = -dz + zch41;
par0[10] = 30.;
par0[11] = 37.5;
// recess erice2000
par0[12] = -dz + zch42;
par0[13] = 30.;
par0[14] = par0[11];
par0[15] = -dz + zch42;
par0[16] = 30.;
par0[17] = 30.+(zch42-zConeE)*TMath::Tan(thetaOpenPbO);
// 5th station
par0[18] = -dz + zch51;
par0[19] = 30.;
par0[20] = 30.+(zch51-zConeE)*TMath::Tan(thetaOpenPbO);
par0[21] = -dz + zch51;
par0[22] = 30.;
par0[23] = 37.5; // recess erice2000
par0[24] = -dz + zch52;
par0[25] = 30.;
par0[26] = par0[23];
par0[27] = -dz + zch52;
par0[28] = 30.;
par0[29] = 30.+(zch52-zConeE)*TMath::Tan(thetaOpenPbO);
// end of cone
par0[30] = +dl;
par0[31] = 30.;
par0[32] = par0[29];
//
gMC->Gsvolu("YOPB", "PCON", idtmed[kPb], par0, 33);
dz = -(zvac12-zstart)/2. + (zch32-zstart) + dl;
gMC->Gspos("YOPB", 1, "YMOT", 0., 0., dz, 0, "ONLY");
}
}
void AliSHILv0::Init()
{
//
// Initialise the muon shield after it has been built
//
Int_t i;
//
if(fDebug) {
printf("\n%s: ",ClassName());
for(i=0;i<35;i++) printf("*");
printf(" SHILv0_INIT ");
for(i=0;i<35;i++) printf("*");
printf("\n%s: ",ClassName());
//
// Here the SHIL initialisation code (if any!)
for(i=0;i<80;i++) printf("*");
printf("\n");
}
}
Avoid overlap of compensation magnet with HALL.
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* Author: The ALICE Off-line Project. *
* Contributors are mentioned in the code where appropriate. *
* *
* Permission to use, copy, modify and distribute this software and its *
* documentation strictly for non-commercial purposes is hereby granted *
* without fee, provided that the above copyright notice appears in all *
* copies and that both the copyright notice and this permission notice *
* appear in the supporting documentation. The authors make no claims *
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
/*
$Log$
Revision 1.14 2001/10/26 08:36:19 morsch
Geometry update.
Revision 1.13 2001/04/23 23:12:41 morsch
Overlap in closing cone corrected (thanks to Ivana Hrivnacova)
Revision 1.12 2001/03/16 16:26:05 morsch
Put vacuum in beam-pipe not air.
Revision 1.11 2000/10/27 15:21:24 morsch
Shield composition after muon project leader meeting: 24/10/2000
- 1 cm recess in steel for station 3
- no heavy shielding between chambers for stations 1 and 2
Revision 1.10 2000/10/02 21:28:15 fca
Removal of useless dependecies via forward declarations
Revision 1.9 2000/09/12 17:00:45 morsch
Overlaps in YMO3 and YMO4 (side-effect from last update only) corrected.
Revision 1.8 2000/09/12 16:11:43 morsch
- Bug in volume YGO2 corrected: PCON started with twice the same z-value.
- Recesses for chambers added to outer Pb cone.
Revision 1.7 2000/06/15 09:40:31 morsch
Obsolete typedef keyword removed
Revision 1.6 2000/06/13 15:01:38 morsch
Make kind of heavy shielding material (Pb, NiCuW) dependent on presence of outer cone.
Revision 1.5 2000/06/12 19:40:00 morsch
New structure of beam pipe and heating jacket.
Optional outer Pb cone added. Not yet compatible with chamber inner radii.
Revision 1.4 2000/04/03 08:13:40 fca
Introduce extra scope for non ANSI compliant C++ compilers
Revision 1.3 2000/01/17 10:29:30 morsch
Overlap between Shield and Absorber due to limited numerical precision removed
by displacing the Shield by epsilon = 0.01 cm.
Revision 1.2 2000/01/13 11:27:51 morsch
Overlaps corrected: YCS3, YCS4; Inner radius YS21 corrected
Revision 1.1 2000/01/12 15:44:03 morsch
Standard version of SHIL
*/
///////////////////////////////////////////////////////////////////////////////
// //
// Muon Shield Class //
// This class contains a description of the muon shield //
// //
//Begin_Html
/*
<img src="picts/AliSHILClass.gif">
*/
//End_Html
// //
// //
///////////////////////////////////////////////////////////////////////////////
#include "AliSHILv0.h"
#include "AliRun.h"
#include "AliMC.h"
#include "AliConst.h"
ClassImp(AliSHILv0)
//_____________________________________________________________________________
AliSHILv0::AliSHILv0()
{
//
// Default constructor for muon shield
//
}
//_____________________________________________________________________________
AliSHILv0::AliSHILv0(const char *name, const char *title)
: AliSHIL(name,title)
{
//
// Standard constructor for muon shield
//
SetMarkerColor(7);
SetMarkerStyle(2);
SetMarkerSize(0.4);
// Pb cone not yet compatible with muon chamber inner radii
// Switched off by default
fPbCone=kTRUE;
}
//_____________________________________________________________________________
void AliSHILv0::CreateGeometry()
{
//
// Build muon shield geometry
//
//
//Begin_Html
/*
<img src="picts/AliSHILv0.gif">
*/
//End_Html
//Begin_Html
/*
<img src="picts/AliSHILv0Tree.gif">
*/
//End_Html
Float_t cpar[5], cpar0[5], tpar[3], par1[39], pars1[100], par2[27], par3[27],
par4[21], par0[45];
Float_t dz, dZ;
Int_t *idtmed = fIdtmed->GetArray()-1699;
#include "ABSOSHILConst.h"
#include "SHILConst.h"
enum {kC=1705, kAl=1708, kFe=1709, kCu=1710, kW=1711, kPb=1712,
kNiCuW=1720, kVacuum=1715, kAir=1714, kConcrete=1716,
kPolyCH2=1717, kSteel=1709, kInsulation=1713};
//
// Material of the rear part of the shield
Int_t iHeavy=kNiCuW;
if (fPbCone) iHeavy=kPb;
//
// Mother volume
//
Float_t dRear1=dRear;
Float_t zstart=zRear-dRear1;
par0[0] = 0.;
par0[1] = 360.;
par0[2] = 28.;
Float_t dl=(zvac12-zstart)/2.;
dz=zstart+dl;
//
// start
par0[3] = -dl;
par0[4] = 0.;
par0[5] = zstart * TMath::Tan(accMin);
// recess station 1
par0[6] = -dz+zch11;
par0[7] = 0.;
par0[8] = zch11 * TMath::Tan(accMin);
par0[9] = par0[6];
par0[10] = 0.;
par0[11] = 17.9;
par0[12] = -dz+zch12;
par0[13] = 0.;
par0[14] = 17.9;
par0[15] = par0[12];
par0[16] = 0.;
par0[17] = zch12 * TMath::Tan(accMin);
// recess station 2
par0[18] = -dz+zch21;
par0[19] = 0.;
par0[20] = zch21 * TMath::Tan(accMin);
par0[21] = -dz+zch21;
par0[22] = 0.;
par0[23] = 23.;
par0[24] = -dz+zch22;
par0[25] = 0.;
par0[26] = 23.;
par0[27] = -dz+zch22;
par0[28] = 0.;
par0[29] = zch22 * TMath::Tan(accMin);
//
par0[30] = -dz+zvac6;
par0[31] = 0.;
par0[32] = zvac6 * TMath::Tan(accMin);
// end of 2 deg cone
par0[33] = -dz+zConeE;
par0[34] = 0.;
par0[35] = 30.;
par0[36] = -dz+zch31;
par0[37] = 0.;
par0[38] = 30.;
par0[39] = -dz+zch31;
par0[40] = 0.;
par0[41] = 29.;
par0[42] = -dz+zch32;
par0[43] = 0.;
par0[44] = 29.;
// start of 1.6 deg cone
par0[45] = -dz+zch32;
par0[46] = 0.;
par0[47] = 30.+(zch32-zConeE)*TMath::Tan(thetaOpenPbO);
// recess station 4
par0[48] = -dz+zch41;
par0[49] = 0.;
par0[50] = 30.+(zch41-zConeE)*TMath::Tan(thetaOpenPbO);
par0[51] = -dz+zch41;
par0[52] = 0.;
par0[53] = 37.5;
par0[54] = -dz+zch42;
par0[55] = 0.;
par0[56] = 37.5;
par0[57] = -dz+zch42;
par0[58] = 0.;
par0[59] = 30.+(zch42-zConeE)*TMath::Tan(thetaOpenPbO);
// recess station 5
par0[60] = -dz+zch51;
par0[61] = 0.;
par0[62] = 30.+(zch51-zConeE)*TMath::Tan(thetaOpenPbO);
par0[63] = -dz+zch51;
par0[64] = 0.;
par0[65] = 37.5;
par0[66] = -dz+zch52;
par0[67] = 0.;
par0[68] = 37.5;
par0[69] = -dz+zch52;
par0[70] = 0.;
par0[71] = 30.+(zch52-zConeE)*TMath::Tan(thetaOpenPbO);
// end of cone
par0[72] = -dz+zvac10;
par0[73] = 0.;
par0[74] = 30.+(zvac10-zConeE)*TMath::Tan(thetaOpenPbO);
par0[75] = -dz+zvac10;
par0[76] = 0.;
par0[77] = R42;
par0[78] = -dz+zvac11;
par0[79] = 0.;
par0[80] = R42;
par0[81] = -dz+zvac11;
par0[82] = 0.;
par0[83] = R43;
par0[84] = -dz+zvac12;
par0[85] = 0.;
par0[86] = R43;
gMC->Gsvolu("YMOT", "PCON", idtmed[kVacuum], par0, 87);
dz=zstart+dl;
gMC->Gspos("YMOT", 1, "ALIC", 0., 0., dz, 0, "ONLY");
//
dZ=-dl;
//
// First section: bellows below and behind front absorber
//
//
par1[0] = 0.;
par1[1] = 360.;
par1[2] = 12.;
dl=(zvac4-zstart)/2.;
par1[3] = -dl;
par1[4] = rAbs+(zstart-zOpen) * TMath::Tan(thetaOpen1);
par1[5] = zstart * TMath::Tan(accMin);
par1[6] = -dl+zvac1-zstart;
par1[7] = rAbs+ (zvac1-zOpen) * TMath::Tan(thetaOpen1);
par1[8] = zvac1 * TMath::Tan(accMin);
par1[9] = par1[6]+dr11/2.;
par1[10] = par1[7]+dr11;
par1[11] = (zvac1+dr11/2.) * TMath::Tan(accMin);
par1[12] = -dl+dRear1;
par1[13] = par1[10];
par1[14] = zRear * TMath::Tan(accMin);
par1[15] = -dl+dRear1;
par1[16] = par1[10];
par1[17] = R11;
par1[18] = -dl+(zvac1+dr11+dB1-zstart);
par1[19] = par1[16];
par1[20] = R11;
par1[21] = par1[18]+dr12;
par1[22] = par1[19]+dr12;
par1[23] = R11;
par1[24] = par1[21]+dF1;
par1[25] = par1[22];
par1[26] = R11;
par1[27] = par1[24]+dr12;
par1[28] = par1[25]-dr12;
par1[29] = R11;
par1[30] = par1[27]+dB1;
par1[31] = par1[28];
par1[32] = R11;
par1[33] = par1[30]+dr13;
par1[34] = par1[31]-dr13;
par1[35] = R11;
par1[36] = -dl+zvac4-zstart;
par1[37] = par1[34];
par1[38] = R11;
Float_t r2 = par1[37];
Float_t rBox= par1[31]-0.1;
Float_t rc1 = par1[7];
gMC->Gsvolu("YGO1", "PCON", idtmed[kNiCuW], par1, 39);
Int_t i;
for (i=0; i<39; i++) pars1[i] = par1[i];
for (i=4; i<38; i+=3) pars1[i] = 0.;
gMC->Gsvolu("YMO1", "PCON", idtmed[kVacuum+40], pars1, 39);
gMC->Gspos("YGO1", 1, "YMO1", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO1", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
// Steel envelope
tpar[0]=R11-dRSteel2;
tpar[1]=R11;
tpar[2]=(zvac4-zvac3)/2.;
gMC->Gsvolu("YSE1", "TUBE", idtmed[kNiCuW], tpar, 3);
dz=dl-tpar[2];
gMC->Gspos("YSE1", 1, "YGO1", 0., 0., dz, 0, "ONLY");
//
// 1st section: vacuum system
//
//
// Bellow 1
//
tpar[0]=rB1;
tpar[1]=rB1+hB1;
tpar[2]=eB1/2.;
gMC->Gsvolu("YB11", "TUBE", idtmed[kSteel+40], tpar, 3);
Float_t dl1=tpar[2];
tpar[0]=rB1+hB1-eB1;
tpar[1]=rB1+hB1;
tpar[2]=(lB1/2.-2.*eB1)/2.;
gMC->Gsvolu("YB12", "TUBE", idtmed[kSteel+40], tpar, 3);
Float_t dl2=tpar[2];
tpar[0]=rB1-eB1;
tpar[1]=rB1;
tpar[2]=lB1/8.;
gMC->Gsvolu("YB13", "TUBE", idtmed[kSteel+40], tpar, 3);
Float_t dl3=tpar[2];
tpar[0]=0;
tpar[1]=rB1+hB1;
tpar[2]=lB1/2.;
gMC->Gsvolu("YBU1", "TUBE", idtmed[kVacuum+40], tpar, 3);
dz=-tpar[2]+dl3;
gMC->Gspos("YB13", 1, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl3;
dz+=dl1;
gMC->Gspos("YB11", 1, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl2;
gMC->Gspos("YB12", 1, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl2;
dz+=dl1;
gMC->Gspos("YB11", 2, "YBU1", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl3;
gMC->Gspos("YB13", 2, "YBU1", 0., 0., dz, 0, "ONLY");
tpar[0]=0;
tpar[1]=rB1+hB1+0.5;
tpar[2]=10.*lB1/2.;
gMC->Gsvolu("YBM1", "TUBE", idtmed[kVacuum+40], tpar, 3);
Float_t bsize = tpar[2];
tpar[0]=rB1+hB1;
gMC->Gsvolu("YBI1", "TUBE", idtmed[kInsulation+40], tpar, 3);
gMC->Gspos("YBI1", 2, "YBM1", 0., 0., 0., 0, "ONLY");
dz=-bsize+lB1/2.;
for (i=0; i<10; i++) {
gMC->Gspos("YBU1", i+1 , "YBM1", 0., 0., dz, 0, "ONLY");
dz+=lB1;
}
dz=-dl+(zvac1-zstart)+dr11+bsize;
gMC->Gspos("YBM1", 1, "YMO1", 0., 0., dz, 0, "ONLY");
dz=dl-dr13-(zvac4-zvac3)-bsize;
gMC->Gspos("YBM1", 2, "YMO1", 0., 0., dz, 0, "ONLY");
//
// Flange
tpar[0]=0;
tpar[1]=rF1+0.6;
tpar[2]=dF1/2.;
gMC->Gsvolu("YFM1", "TUBE", idtmed[kVacuum+40], tpar, 3);
// Steel
tpar[0]=rB1;
tpar[1]=rF1+0.6;
tpar[2]=dF1/2.;
gMC->Gsvolu("YF11", "TUBE", idtmed[kSteel+40], tpar, 3);
// Insulation
tpar[0]=rF1;
tpar[1]=rF1+0.5;
tpar[2]=dF1/2.;
gMC->Gsvolu("YF12", "TUBE", idtmed[kInsulation+40], tpar, 3);
gMC->Gspos("YF11", 1, "YFM1", 0., 0., 0., 0, "ONLY");
gMC->Gspos("YF12", 1, "YFM1", 0., 0., 0., 0, "ONLY");
dz=-dl+(zvac2-zstart);
gMC->Gspos("YFM1", 2, "YMO1", 0., 0., dz, 0, "ONLY");
//
// pipe between flange and bellows
//
// Steel
tpar[0]=rB1-dTubeS;
tpar[1]=rB1+0.6;
tpar[2]=2.*(dB1+dr12-10.*lB1)/4.;
gMC->Gsvolu("YPF1", "TUBE", idtmed[kSteel+40], tpar, 3);
// Insulation
tpar[0]=rB1;
tpar[1]=rB1+0.5;
gMC->Gsvolu("YPS1", "TUBE", idtmed[kInsulation+40], tpar, 3);
gMC->Gspos("YPS1", 1, "YPF1", 0., 0., 0., 0, "ONLY");
dz=-dl+(zvac2-zstart)-dF1/2.-tpar[2];
gMC->Gspos("YPF1", 1, "YMO1", 0., 0., dz, 0, "ONLY");
dz=-dl+(zvac2-zstart)+dF1/2.+tpar[2];
gMC->Gspos("YPF1", 2, "YMO1", 0., 0., dz, 0, "ONLY");
// Pipe+Heating 1.5 mm
// Heating Jacket 5.0 mm
// Protection 1.0 mm
// ========================
// 7.5 mm
// pipe and heating jackets outside bellows
//
// left side
cpar0[0]=(zvac1+dr11-zstart)/2;
cpar0[1]=rVacu-0.05 +(zstart-zOpen)*TMath::Tan(thetaOpen1);
cpar0[2]=rVacu+0.7 +(zstart-zOpen)*TMath::Tan(thetaOpen1);
cpar0[3]=cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpen1);
cpar0[4]=cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpen1);
gMC->Gsvolu("YV11", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
dTubeS=0.15;
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+0.15;
cpar[2]=cpar0[1]+0.65;
cpar[3]=cpar0[3]+0.15;
cpar[4]=cpar0[3]+0.65;
gMC->Gsvolu("YI11", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI11", 1, "YV11", 0., 0., 0., 0, "ONLY");
dz=-dl+cpar0[0];
gMC->Gspos("YV11", 1, "YMO1", 0., 0., dz, 0, "ONLY");
// right side
dTubeS = 0.35;
dVacuS += 0.25;
cpar0[0] = (zvac4-zvac3)/2;
cpar0[1] = rB1;
cpar0[2] = cpar0[1]+dVacuS;
cpar0[3] = cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
cpar0[4] = cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
gMC->Gsvolu("YV12", "CONE", idtmed[kSteel], cpar0, 5);
Float_t r2V=cpar0[3];
//
// insulation
cpar[0] = cpar0[0];
cpar[1] = cpar0[1]+dTubeS;
cpar[2] = cpar0[1]+dTubeS+dInsuS;
cpar[3] = cpar0[3]+dTubeS;
cpar[4] = cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI12", "CONE", idtmed[kInsulation], cpar, 5);
gMC->Gspos("YI12", 1, "YV12", 0., 0., 0., 0, "ONLY");
dz=dl-cpar0[0];
gMC->Gspos("YV12", 1, "YMO1", 0., 0., dz, 0, "ONLY");
//
// Second Section
// Between first and second bellow section
//
par2[0] = 0.;
par2[1] = 360.;
par2[2] = 11.;
dl=(zvac7-zvac4)/2.;
// recess station 2
par2[3] = -dl;
par2[4] = r2;
par2[5] = R21;
par2[6] = -dl+.1;
par2[7] = r2;
par2[8] = R21;
par2[9] = -dl+(zvac6-zvac4);
par2[10] = r2+(zvac6-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[11] = R21;
par2[12] = -dl+(zvac6-zvac4);
par2[13] = par2[10];
par2[14] = zvac6*TMath::Tan(accMin);
// Start of Pb section
par2[15] = -dl+(zPb-zvac4);
par2[16] = r2+(zPb-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[17] = zPb*TMath::Tan(accMin);
//
// end of cone following 2 deg line
par2[18] = -dl+(zConeE-zvac4);
par2[19] = r2+(zConeE-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[20] = 30.;
// recess station 3
par2[21] = -dl+(zch31-zvac4);
par2[22] = r2+(zch31-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[23] = 30.;
par2[24] = -dl+(zch31-zvac4);
par2[25] = r2+(zch31-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[26] = 29.;
par2[27] = -dl+(zch32-zvac4);
par2[28] = r2+(zch32-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[29] = 29.;
par2[30] = -dl+(zch32-zvac4);
par2[31] = r2+(zch32-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[32] = 30.;
par2[33] = -dl+(zvac7-zvac4);
par2[34] = r2+(zvac7-zvac4-10.) * TMath::Tan(thetaOpen2);
par2[35] = 30.;
gMC->Gsvolu("YGO2", "PCON", idtmed[kSteel+40], par2, 36);
//
// Lead cone
//
Float_t parPb[12];
parPb[0] = 0.;
parPb[1] = 360.;
parPb[2] = 3.;
Float_t dlPb=(zvac7-zPb)/2.;
parPb[3] = -dlPb;
parPb[4] = r2+(zPb-zvac4-10.) * TMath::Tan(thetaOpen2);
parPb[5] = zPb*TMath::Tan(accMin)-dRSteel2;
parPb[6] = -dlPb+(zConeE-zPb);
parPb[7] = r2+(zConeE-zvac4-10.) * TMath::Tan(thetaOpen2);
parPb[8] = 26.;
parPb[9] = dlPb;
parPb[10] = r2+(zvac7-zvac4-10.) * TMath::Tan(thetaOpen2);
parPb[11] = 26.;
gMC->Gsvolu("YXO2", "PCON", idtmed[kPb], parPb, 12);
gMC->Gspos("YXO2", 1, "YGO2", 0., 0., (zPb-zvac4)/2., 0, "ONLY");
//
// W cone
//
Float_t parW[15];
parW[0] = 0.;
parW[1] = 360.;
parW[2] = 4.;
Float_t dlW=(zPb-zvac4)/2.;
parW[3] = -dlW;
parW[4] = r2;
parW[5] = R21-dRSteel2;
parW[6] = -dlW+(zvac6-zvac4)+dRSteel2;
parW[7] = r2+(zvac6-zvac4+dRSteel2) * TMath::Tan(thetaOpen2);
parW[8] = R21-dRSteel2;
parW[9] = -dlW+(zvac6-zvac4)+dRSteel2;
parW[10] = r2+(zvac6-zvac4+dRSteel2) * TMath::Tan(thetaOpen2);
parW[11] = (zvac6+dRSteel2)*TMath::Tan(accMin)-dRSteel2;
parW[12] = dlW;
parW[13] = r2+(zPb-zvac4) * TMath::Tan(thetaOpen2);
parW[14] = zPb*TMath::Tan(accMin)-dRSteel2;
gMC->Gsvolu("YYO2", "PCON", idtmed[kNiCuW], parW, 15);
gMC->Gspos("YYO2", 1, "YGO2", 0., 0., -(zvac7-zPb)/2., 0, "ONLY");
for (i=4; i<35; i+=3) par2[i] = 0;
gMC->Gsvolu("YMO2", "PCON", idtmed[kVacuum+40], par2, 36);
gMC->Gspos("YGO2", 1, "YMO2", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO2", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
//
// 2nd section: vacuum system
//
cpar0[0]=(zvac7-zvac4)/2;
cpar0[1]=r2V;
cpar0[2]=r2V+dVacuS;
cpar0[3]=cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
cpar0[4]=cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpenB);
gMC->Gsvolu("YV21", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+dTubeS;
cpar[2]=cpar0[1]+dTubeS+dInsuS;
cpar[3]=cpar0[3]+dTubeS;
cpar[4]=cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI21", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI21", 1, "YV21", 0., 0., 0., 0, "ONLY");
gMC->Gspos("YV21", 1, "YMO2", 0., 0., 0., 0, "ONLY");
//
// Third Section: Bellows and Flange
//
par3[0] = 0.;
par3[1] = 360.;
par3[2] = 8.;
dl=(zvac9-zvac7)/2.;
par3[3] = -dl;
par3[4] = r2+(zvac7-zvac3) * TMath::Tan(thetaOpen2);
par3[5] = 30.;
par3[6] = -dl+dr21;
par3[7] = par3[4]+dr21;
par3[8] = 30.;
par3[9] = par3[6]+dB2;
par3[10] = par3[7];
par3[11] = 30.;
par3[12] = par3[9]+dr22;
par3[13] = par3[10]+dr22;
par3[14] = 30.;
par3[15] = par3[12]+dF2;
par3[16] = par3[13];
par3[17] = 30.;
par3[18] = par3[15]+dr22;
par3[19] = par3[16]-dr22;
par3[20] = 30.;
par3[21] = par3[18]+dB2;
par3[22] = par3[19];
par3[23] = 30.;
par3[24] = par3[21]+dr23;
par3[25] = par3[22];
par3[26] = 30.;
//
rBox=par3[22]-0.1;
Float_t r3=par3[25];
gMC->Gsvolu("YGO3", "PCON", idtmed[iHeavy+40], par3, 27);
for (i=4; i<26; i+=3) par3[i] = 0;
gMC->Gsvolu("YMO3", "PCON", idtmed[kVacuum+40], par3, 27);
gMC->Gspos("YGO3", 1, "YMO3", 0., 0., 0., 0, "ONLY");
//
// Steel envelope
tpar[0]=26;
tpar[1]=30;
tpar[2]=dl;
gMC->Gsvolu("YS31", "TUBE", idtmed[kSteel], tpar, 3);
gMC->Gspos("YS31", 1, "YGO3", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO3", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
// 3rd section: vacuum system
//
//
// Bellow2
//
tpar[0]=rB2;
tpar[1]=rB2+hB2;
tpar[2]=eB2/2.;
gMC->Gsvolu("YB21", "TUBE", idtmed[kSteel+40], tpar, 3);
dl1=tpar[2];
tpar[0]=rB2+hB2-eB2;
tpar[1]=rB2+hB2;
tpar[2]=(lB2/2.-2.*eB2)/2.;
gMC->Gsvolu("YB22", "TUBE", idtmed[kSteel+40], tpar, 3);
dl2=tpar[2];
tpar[0]=rB2-eB2;
tpar[1]=rB2;
tpar[2]=lB2/8.;
gMC->Gsvolu("YB23", "TUBE", idtmed[kSteel+40], tpar, 3);
dl3=tpar[2];
tpar[0]=0;
tpar[1]=rB2+hB2;
tpar[2]=lB2/2.;
gMC->Gsvolu("YBU2", "TUBE", idtmed[kVacuum+40], tpar, 3);
dz=-tpar[2]+dl3;
gMC->Gspos("YB23", 1, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl3;
dz+=dl1;
gMC->Gspos("YB21", 1, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl2;
gMC->Gspos("YB22", 1, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl2;
dz+=dl1;
gMC->Gspos("YB21", 2, "YBU2", 0., 0., dz, 0, "ONLY");
dz+=dl1;
dz+=dl3;
gMC->Gspos("YB23", 2, "YBU2", 0., 0., dz, 0, "ONLY");
tpar[0]=0;
tpar[1]=rB2+hB2;
tpar[2]=7.*lB2/2.;
gMC->Gsvolu("YBM2", "TUBE", idtmed[kVacuum+40], tpar, 3);
dz=-tpar[2]+lB2/2.;
for (i=0; i<7; i++) {
gMC->Gspos("YBU2", i+1 , "YBM2", 0., 0.,dz , 0, "ONLY");
dz+=lB2;
}
dz=-dl+dr21+tpar[2];
gMC->Gspos("YBM2", 1, "YMO3", 0., 0., dz, 0, "ONLY");
dz=dl-dr23-tpar[2];
gMC->Gspos("YBM2", 2, "YMO3", 0., 0., dz, 0, "ONLY");
//
// Flange
tpar[0]=0;
tpar[1]=rF2;
tpar[2]=dF2/2.;
gMC->Gsvolu("YFM2", "TUBE", idtmed[kVacuum+40], tpar, 3);
tpar[0]=rF2-2.;
tpar[1]=rF2;
tpar[2]=dF2/2.;
gMC->Gsvolu("YF21", "TUBE", idtmed[kSteel+40], tpar, 3);
gMC->Gspos("YF21", 1, "YFM2", 0., 0., 0., 0, "ONLY");
tpar[0]=rB2;
tpar[1]=rF2-2.;
tpar[2]=dFlange/2.;
gMC->Gsvolu("YF22", "TUBE", idtmed[kSteel+40], tpar, 3);
dz=-dF2/2.+tpar[2];
gMC->Gspos("YF22", 1, "YFM2", 0., 0., dz, 0, "ONLY");
dz= dF2/2.-tpar[2];
gMC->Gspos("YF22", 2, "YFM2", 0., 0., dz, 0, "ONLY");
dz=dr21/2.-dr23/2.;
gMC->Gspos("YFM2", 2, "YMO3", 0., 0., dz, 0, "ONLY");
//
// pipe between flange and bellows
tpar[0]=rB2-dTubeS;
tpar[1]=rB2;
tpar[2]=2.*(dB2+dr22-7.*lB2)/4.;
gMC->Gsvolu("YPF2", "TUBE", idtmed[kSteel+40], tpar, 3);
dz=dr21/2.-dr23/2.-dF2/2.-tpar[2];
gMC->Gspos("YPF2", 1, "YMO3", 0., 0., dz, 0, "ONLY");
dz=dr21/2.-dr23/2.+dF2/2.+tpar[2];
gMC->Gspos("YPF2", 2, "YMO3", 0., 0., dz, 0, "ONLY");
Float_t dHorZ=20.;
//
// 4th section: rear shield and closing cone
//
par4[0] = 0.;
par4[1] = 360.;
par4[2] = 7.;
dl=(zvac12-zvac9)/2.;
par4[3] = -dl;
par4[4] = r3;
par4[5] = 30.;
par4[6] = -dl+dHorZ;
par4[7] = r3;
par4[8] = 30.;
par4[9] = -dl+(zvac10-zvac9);
par4[10] = r3+(zvac10-zvac9-dHorZ) * TMath::Tan(thetaOpen3);
par4[11] = 30.;
par4[12] = par4[9];
par4[13] = par4[10];
par4[14] = R42;
par4[15] = -dl+(zvac11-zvac9);
par4[16] = r3+(zvac11-zvac9-dHorZ) * TMath::Tan(thetaOpen3);
par4[17] = R42;
par4[18] = par4[15];
par4[19] = par4[16];
par4[20] = R43;
par4[21] = -dl+(zvac12-zvac9);
par4[22] = rVacu+dVacuS;
par4[23] = R43;
gMC->Gsvolu("YGO4", "PCON", idtmed[iHeavy+40], par4, 24);
parPb[0] = (zvac12-zvac10)/2.;
parPb[1] = parPb[3];
parPb[2] = 31.;
parPb[3] = parPb[1]+2.*parPb[0]*TMath::Tan(thetaOpenPb);
parPb[4] = 31.;
gMC->Gsvolu("YXO5", "CONE", idtmed[kPb], parPb, 5);
gMC->Gspos("YXO5", 1, "YGO4", 0., 0., -dl+(zvac10-zvac9)+parPb[0], 0, "ONLY");
for (i=4; i<23; i+=3) par4[i] = 0;
gMC->Gsvolu("YMO4", "PCON", idtmed[kVacuum+40], par4, 24);
gMC->Gspos("YGO4", 1, "YMO4", 0., 0., 0., 0, "ONLY");
dZ+=dl;
gMC->Gspos("YMO4", 1, "YMOT", 0., 0., dZ, 0, "ONLY");
dZ+=dl;
//
// Closing concrete cone
//
cpar[0]=(zvac12-zvac11)/2.;
cpar[1] = r3+(zvac11-zvac9-dHorZ) * TMath::Tan(thetaOpen3);
cpar[2] = cpar[1]+0.001;
cpar[3] = rVacu+dVacuS;
cpar[4] = cpar[2];
gMC->Gsvolu("YCC4", "CONE", idtmed[kConcrete+40], cpar, 5);
dz=dl-cpar[0];
gMC->Gspos("YCC4", 1, "YGO4", 0., 0., dz, 0, "ONLY");
//
// Steel envelope
//
dz=-dl;
tpar[0]=26.;
tpar[1]=30.;
tpar[2]=(zvac10-zvac9)/2.;
gMC->Gsvolu("YS41", "TUBE", idtmed[kSteel], tpar, 3);
dz+=tpar[2];
gMC->Gspos("YS41", 1, "YGO4", 0., 0., dz, 0, "ONLY");
dz+=tpar[2];
tpar[0]=R41-dRSteel2;
tpar[1]=R41;
tpar[2]=(zvac11-zvac10)/2.;
gMC->Gsvolu("YS43", "TUBE", idtmed[kPb], tpar, 3);
dz+=tpar[2];
gMC->Gspos("YS43", 1, "YGO4", 0., 0., dz, 0, "ONLY");
//
// rear lead shield
//
tpar[0]=R41;
tpar[1]=R42;
tpar[2]=(zvac11-zvac10)/2.;
gMC->Gsvolu("YPBI", "TUBE", idtmed[kPb+40], tpar, 3);
dz-=0;
gMC->Gspos("YPBI", 1, "YGO4", 0., 0., dz, 0, "ONLY");
tpar[0]=R42-5;
tpar[1]=R42;
tpar[2]=(zvac11-zvac10)/2.;
gMC->Gsvolu("YPBO", "TUBE", idtmed[kPb], tpar, 3);
gMC->Gspos("YPBO", 1, "YPBI", 0., 0., 0., 0, "ONLY");
//
// rear Fe shield
//
tpar[0]=31.;
tpar[1]=R43;
tpar[2]=(zvac12-zvac11)/2.;
gMC->Gsvolu("YFEI", "TUBE", idtmed[kFe+40], tpar, 3);
dz=dl-tpar[2];
gMC->Gspos("YFEI", 1, "YGO4", 0., 0., dz, 0, "ONLY");
tpar[0]=31.;
tpar[1]=R43;
tpar[2]=2.5;
gMC->Gsvolu("YFEO", "TUBE", idtmed[kFe], tpar, 3);
dz=-(zvac12-zvac11)/2.+tpar[2];
gMC->Gspos("YFEO", 1, "YFEI", 0., 0., dz, 0, "ONLY");
//
// Magnet element
//
tpar[0]=0.;
tpar[1]=R43;
tpar[2]=60.;
gMC->Gsvolu("YAEM", "TUBE", idtmed[kAir], tpar, 3);
tpar[0]=rAbs;
tpar[1]=R43;
tpar[2]=60.;
gMC->Gsvolu("YFEM", "TUBE", idtmed[kFe], tpar, 3);
gMC->Gspos("YFEM", 1, "YAEM", 0., 0., 0., 0, "ONLY");
//
if (gMC->VolId("HUP2")) {
gMC->Gspos("YAEM", 1, "HUP2", 0., 0., 0., 0, "ONLY");
} else {
dz=zvac12+60.;
gMC->Gspos("YAEM", 1, "ALIC", 0., 0., dz, 0, "ONLY");
}
//
//
// 4th section: vacuum system
//
// up to closing cone
Float_t r3V=r3-dr23+dVacuS-1.6;
cpar0[0]=(zvac11-zvac9)/2;
cpar0[1]=r3V-dVacuS;
cpar0[2]=r3V;
cpar0[3]=cpar0[1]+2.*cpar0[0]*TMath::Tan(thetaOpen3);
cpar0[4]=cpar0[2]+2.*cpar0[0]*TMath::Tan(thetaOpen3);
gMC->Gsvolu("YV31", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+dTubeS;
cpar[2]=cpar0[1]+dTubeS+dInsuS;
cpar[3]=cpar0[3]+dTubeS;
cpar[4]=cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI31", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI31", 1, "YV31", 0., 0., 0., 0, "ONLY");
dz=-dl+cpar[0];
gMC->Gspos("YV31", 1, "YMO4", 0., 0., dz, 0, "ONLY");
//
// closing cone
cpar0[0]=(zvac12-zvac11)/2;
cpar0[1]=r3V-dVacuS+(zvac11-zvac9)*TMath::Tan(thetaOpen3);
cpar0[2]=r3V +(zvac11-zvac9)*TMath::Tan(thetaOpen3);
cpar0[3]=rVacu;
cpar0[4]=rVacu+dTubeS+dInsuS+dProtS+dFreeS;
gMC->Gsvolu("YV32", "CONE", idtmed[kSteel+40], cpar0, 5);
//
// insulation
cpar[0]=cpar0[0];
cpar[1]=cpar0[1]+dTubeS;
cpar[2]=cpar0[1]+dTubeS+dInsuS;
cpar[3]=cpar0[3]+dTubeS;
cpar[4]=cpar0[3]+dTubeS+dInsuS;
gMC->Gsvolu("YI32", "CONE", idtmed[kInsulation+40], cpar, 5);
gMC->Gspos("YI32", 1, "YV32", 0., 0., 0., 0, "ONLY");
//
// clearance
cpar[1]=cpar0[2]-dProtS-dFreeS;
cpar[2]=cpar0[2]-dProtS;
cpar[3]=cpar0[4]-dProtS-dFreeS;
cpar[4]=cpar0[4]-dProtS;
gMC->Gsvolu("YP32", "CONE", idtmed[kVacuum+40], cpar, 5);
gMC->Gspos("YP32", 1, "YV32", 0., 0., 0., 0, "ONLY");
dz=dl-cpar[0];
gMC->Gspos("YV32", 1, "YMO4", 0., 0., dz, 0, "ONLY");
//
//
// MUON trigger wall
//
tpar[0] = 50.;
tpar[1] = 310.;
tpar[2] = (zFilterOut - zFilterIn) / 2.;
gMC->Gsvolu("YFIM", "TUBE", idtmed[kFe+40], tpar, 3);
dz = (zFilterIn + zFilterOut) / 2.;
tpar[2] -= 10.;
gMC->Gsvolu("YFII","TUBE", idtmed[kFe], tpar, 3);
gMC->Gspos("YFII", 1, "YFIM", 0., 0., 0., 0, "ONLY");
gMC->Gspos("YFIM", 1, "ALIC", 0., 0., dz, 0, "ONLY");
//
// Shielding close to chamber
//
//
cpar[0]=(zch11-zRear)/2.;
cpar[1]=R11;
cpar[2]=zRear*TMath::Tan(accMin);
cpar[3]=R11;
cpar[4]=(zRear+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS1", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zRear-zstart)+cpar[0];
gMC->Gspos("YCS1", 1, "YMOT", 0., 0., dz, 0, "ONLY");
cpar[0]=(zvac4-zch12)/2.;
cpar[1]=R11;
cpar[2]=zch12*TMath::Tan(accMin);
cpar[3]=R11;
cpar[4]=(zch12+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS3", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch12-zstart)+cpar[0];
gMC->Gspos("YCS3", 1, "YMOT", 0., 0., dz, 0, "ONLY");
// Recess station 1
cpar[0]=(zch12-zch11)/2.;
cpar[1]=R11;
cpar[2]=18.;
cpar[3]=R11;
cpar[4]=17.9;
gMC->Gsvolu("YCS2", "CONE", idtmed[kAir], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch11-zstart)+cpar[0];
gMC->Gspos("YCS2", 1, "YMOT", 0., 0., dz, 0, "ONLY");
Float_t ptubs[5];
ptubs[0] = R11;
ptubs[1] = 17.9;
ptubs[2] = 0.;
// phi_min, phi_max
ptubs[3] = 0.;
ptubs[4] = 90.;
gMC->Gsvolu("YCR0", "TUBS", idtmed[kNiCuW], ptubs, 0);
Int_t idrotm[1799];
AliMatrix(idrotm[1701],90., 0., 90., 90., 0., 0.);
AliMatrix(idrotm[1702],90., 90., 90., 180., 0., 0.);
AliMatrix(idrotm[1703],90., 180., 90., 270., 0., 0.);
AliMatrix(idrotm[1704],90., 270., 90., 0., 0., 0.);
// Int_t ipos;
dz=-cpar[0];
// 1.
ptubs[2]=6.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 1, "YCS2", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 2, "YCS2", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 2.
ptubs[2]=5.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 3, "YCS2", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 4, "YCS2", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 3.
ptubs[2]=5.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 5, "YCS2", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 6, "YCS2", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 4.
ptubs[2]=6.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR0", 7, "YCS2", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR0", 8, "YCS2", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
cpar[0]=(zch21-zvac4)/2.;
cpar[1]=R21;
cpar[2]=zvac4*TMath::Tan(accMin);
cpar[3]=R21;
cpar[4]=(zvac4+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS4", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zvac4-zstart)+cpar[0];
gMC->Gspos("YCS4", 1, "YMOT", 0., 0., dz, 0, "ONLY");
cpar[0]=(zvac6-zch22)/2.;
cpar[1]=R21;
cpar[2]=zch22*TMath::Tan(accMin);
cpar[3]=R21;
cpar[4]=(zch22+2.*cpar[0])*TMath::Tan(accMin);
gMC->Gsvolu("YCS6", "CONE", idtmed[kNiCuW], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch22-zstart)+cpar[0];
gMC->Gspos("YCS6", 1, "YMOT", 0., 0., dz, 0, "ONLY");
// Recess station 2
cpar[0]=(zch22-zch21)/2.;
cpar[1]=R21;
cpar[2]=23.;
cpar[3]=R21;
cpar[4]=23.;
gMC->Gsvolu("YCS5", "CONE", idtmed[kAir], cpar, 5);
dz=-(zvac12-zstart)/2.+(zch21-zstart)+cpar[0];
gMC->Gspos("YCS5", 1, "YMOT", 0., 0., dz, 0, "ONLY");
ptubs[0] = R21;
ptubs[1] = 23;
ptubs[2] = 0.;
ptubs[3] = 0.;
ptubs[4] = 90.;
gMC->Gsvolu("YCR1", "TUBS", idtmed[kNiCuW], ptubs, 0);
dz=-cpar[0];
// 1.
ptubs[2]=7.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 1, "YCS5", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 2, "YCS5", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 2.
ptubs[2]=6.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 3, "YCS5", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 4, "YCS5", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 3.
ptubs[2]=6.0/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 5, "YCS5", 0., 0., dz, idrotm[1701], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 6, "YCS5", 0., 0., dz, idrotm[1703], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
// 4.
ptubs[2]=7.5/2.;
dz+=ptubs[2];
gMC->Gsposp("YCR1", 7, "YCS5", 0., 0., dz, idrotm[1702], "ONLY", ptubs, 5);
gMC->Gsposp("YCR1", 8, "YCS5", 0., 0., dz, idrotm[1704], "ONLY", ptubs, 5);
dz+=ptubs[2];
dz+=1.5;
//
// Outer Pb Cone
if (fPbCone) {
dl = (zvac10-zch32)/2.;
dz = dl+zch32;
par0[0] = 0.;
par0[1] = 360.;
par0[2] = 10.;
par0[ 3] = -dl;
par0[ 4] = 30.;
par0[ 5] = 30.+(zch32-zConeE)*TMath::Tan(thetaOpenPbO);
// 4th station
par0[ 6] = -dz + zch41;
par0[ 7] = 30.;
par0[ 8] = 30.+(zch41-zConeE)*TMath::Tan(thetaOpenPbO);
par0[ 9] = -dz + zch41;
par0[10] = 30.;
par0[11] = 37.5;
// recess erice2000
par0[12] = -dz + zch42;
par0[13] = 30.;
par0[14] = par0[11];
par0[15] = -dz + zch42;
par0[16] = 30.;
par0[17] = 30.+(zch42-zConeE)*TMath::Tan(thetaOpenPbO);
// 5th station
par0[18] = -dz + zch51;
par0[19] = 30.;
par0[20] = 30.+(zch51-zConeE)*TMath::Tan(thetaOpenPbO);
par0[21] = -dz + zch51;
par0[22] = 30.;
par0[23] = 37.5; // recess erice2000
par0[24] = -dz + zch52;
par0[25] = 30.;
par0[26] = par0[23];
par0[27] = -dz + zch52;
par0[28] = 30.;
par0[29] = 30.+(zch52-zConeE)*TMath::Tan(thetaOpenPbO);
// end of cone
par0[30] = +dl;
par0[31] = 30.;
par0[32] = par0[29];
//
gMC->Gsvolu("YOPB", "PCON", idtmed[kPb], par0, 33);
dz = -(zvac12-zstart)/2. + (zch32-zstart) + dl;
gMC->Gspos("YOPB", 1, "YMOT", 0., 0., dz, 0, "ONLY");
}
}
void AliSHILv0::Init()
{
//
// Initialise the muon shield after it has been built
//
Int_t i;
//
if(fDebug) {
printf("\n%s: ",ClassName());
for(i=0;i<35;i++) printf("*");
printf(" SHILv0_INIT ");
for(i=0;i<35;i++) printf("*");
printf("\n%s: ",ClassName());
//
// Here the SHIL initialisation code (if any!)
for(i=0;i<80;i++) printf("*");
printf("\n");
}
}
|
#include "commentTab.h"
#include "patch.h"
#include <time.h>
#include "win32.h"
#include <stdexcept>
using namespace std;
void commentTabChtml::indentHtml(ostream& stream, int indent) {
}
void commentTabChtml::indentEndHtml(ostream& stream) {
}
const char* commentTabChtml::patch(const char* date) {
// parse string date to time_t
// search through patch version list
struct tm tm;
const char* res = strptime(date, "%Y/%m/%d %T", &tm);
if(!res)
throw logic_error("commentTabChtml::patch: strptime failed");
time_t t = timegm(&tm);
for(int i=0; i<gnPatchVersions; i++) {
if(t < gPatchVersions[i].time)
return gPatchVersions[i].name;
}
throw logic_error("commentTabChtml::patch: invalid date");
}
Comments: Fixed patch calculation.
#include "commentTab.h"
#include "patch.h"
#include <time.h>
#include "win32.h"
#include <stdexcept>
using namespace std;
void commentTabChtml::indentHtml(ostream& stream, int indent) {
}
void commentTabChtml::indentEndHtml(ostream& stream) {
}
const char* commentTabChtml::patch(const char* date) {
// parse string date to time_t
// search through patch version list
struct tm tm;
const char* res = strptime(date, "%Y/%m/%d %T", &tm);
if(!res)
throw logic_error("commentTabChtml::patch: strptime failed");
time_t t = timegm(&tm);
for(int i=1; i<gnPatchVersions; i++) {
if(t < gPatchVersions[i].time)
return gPatchVersions[i-1].name;
}
throw logic_error("commentTabChtml::patch: invalid date");
}
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: DomainMapper.cxx,v $
*
* $Revision: 1.69 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include <dmapper/DomainMapper.hxx>
#include <DomainMapper_Impl.hxx>
#include <ConversionHelper.hxx>
#include <ThemeTable.hxx>
#include <ModelEventListener.hxx>
#include <MeasureHandler.hxx>
#include <OLEHandler.hxx>
#include <i18npool/mslangid.hxx>
#include <i18npool/paper.hxx>
#include <ooxml/OOXMLFastTokens.hxx>
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#include <com/sun/star/document/XOOXMLDocumentPropertiesImporter.hpp>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/RelOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/WrapTextMode.hpp>
#include <com/sun/star/text/SizeType.hpp>
#include <com/sun/star/text/XEndnotesSupplier.hpp>
#include <com/sun/star/text/XFootnotesSupplier.hpp>
#include <com/sun/star/text/XLineNumberingProperties.hpp>
#include <com/sun/star/text/XTextDocument.hpp>
#include <com/sun/star/text/XTextCursor.hpp>
#include <com/sun/star/text/XTextPortionAppend.hpp>
#include <com/sun/star/text/XParagraphAppend.hpp>
#include <com/sun/star/text/FontEmphasis.hpp>
#include <com/sun/star/awt/FontRelief.hpp>
#include <com/sun/star/awt/FontWeight.hpp>
#include <com/sun/star/awt/FontUnderline.hpp>
#include <com/sun/star/awt/FontStrikeout.hpp>
#include <com/sun/star/awt/FontSlant.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/document/XEventBroadcaster.hpp>
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/style/BreakType.hpp>
#include <com/sun/star/style/CaseMap.hpp>
#include <com/sun/star/style/LineSpacing.hpp>
#include <com/sun/star/style/LineSpacingMode.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <com/sun/star/text/TextGridMode.hpp>
#include <com/sun/star/text/XDocumentIndexesSupplier.hpp>
#include <com/sun/star/text/WritingMode.hpp>
#include <com/sun/star/text/XFootnote.hpp>
#include <com/sun/star/style/NumberingType.hpp>
#include <comphelper/types.hxx>
#include <comphelper/storagehelper.hxx>
#include <rtl/ustrbuf.hxx>
#include <boost/shared_ptr.hpp>
#include <com/sun/star/uno/Any.hxx>
#include <tools/color.hxx>
#include <BorderHandler.hxx>
#include <CellColorHandler.hxx>
#include <SectionColumnHandler.hxx>
#include <vector>
#include <iostream>
#ifdef DEBUG_DOMAINMAPPER
#include <resourcemodel/QNameToString.hxx>
#include <resourcemodel/util.hxx>
#include <resourcemodel/TagLogger.hxx>
#endif
#if OSL_DEBUG_LEVEL > 0
#include <resourcemodel/QNameToString.hxx>
#endif
using namespace ::com::sun::star;
using namespace ::rtl;
namespace writerfilter {
namespace dmapper{
#ifdef DEBUG_DOMAINMAPPER
TagLogger::Pointer_t dmapper_logger(TagLogger::getInstance("DOMAINMAPPER"));
#endif
/* ---- Fridrich's mess begins here ---- */
struct _PageSz
{
sal_Int32 code;
sal_Int32 h;
bool orient;
sal_Int32 w;
} CT_PageSz;
/* ---- Fridrich's mess (hopefully) ends here ---- */
/*-- 09.06.2006 09:52:11---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::DomainMapper( const uno::Reference< uno::XComponentContext >& xContext,
uno::Reference< io::XInputStream > xInputStream,
uno::Reference< lang::XComponent > xModel,
SourceDocumentType eDocumentType) :
m_pImpl( new DomainMapper_Impl( *this, xContext, xModel, eDocumentType )),
mnBackgroundColor(0), mbIsHighlightSet(false)
{
// #i24363# tab stops relative to indent
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_TABS_RELATIVE_TO_INDENT ),
uno::makeAny( false ) );
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_PARA_TABLE_SPACING ),
uno::makeAny( false ) );
//import document properties
try
{
uno::Reference< lang::XMultiServiceFactory > xFactory(xContext->getServiceManager(), uno::UNO_QUERY_THROW);
uno::Reference< embed::XStorage > xDocumentStorage =
(comphelper::OStorageHelper::GetStorageOfFormatFromInputStream(OFOPXML_STORAGE_FORMAT_STRING, xInputStream));
uno::Reference< uno::XInterface > xTemp = xContext->getServiceManager()->createInstanceWithContext(
::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.OOXMLDocumentPropertiesImporter")),
xContext);
uno::Reference< document::XOOXMLDocumentPropertiesImporter > xImporter( xTemp, uno::UNO_QUERY_THROW );
uno::Reference< document::XDocumentPropertiesSupplier > xPropSupplier( xModel, uno::UNO_QUERY_THROW);
xImporter->importProperties( xDocumentStorage, xPropSupplier->getDocumentProperties() );
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("domainmapper");
#endif
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::~DomainMapper()
{
try
{
uno::Reference< text::XDocumentIndexesSupplier> xIndexesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
uno::Reference< container::XIndexAccess > xIndexes = xIndexesSupplier->getDocumentIndexes();
sal_Int32 nIndexes = xIndexes->getCount();
if( nIndexes )
{
//index update has to wait until first view is created
uno::Reference< document::XEventBroadcaster > xBroadcaster(xIndexesSupplier, uno::UNO_QUERY);
xBroadcaster->addEventListener(uno::Reference< document::XEventListener >(new ModelEventListener));
}
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
delete m_pImpl;
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("domainmapper");
#endif
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::attribute(Id nName, Value & val)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("attribute");
dmapper_logger->attribute("name", (*QNameToString::Instance())(nName));
dmapper_logger->attribute("value", val.toString());
#endif
static ::rtl::OUString sLocalBookmarkName;
sal_Int32 nIntValue = val.getInt();
rtl::OUString sStringValue = val.getString();
// printf ( "DomainMapper::attribute(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nName, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
if( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR )
m_pImpl->GetFIB().SetData( nName, nIntValue );
else //if( !m_pImpl->getTableManager().attribute( nName, val) )
{
/* WRITERFILTERSTATUS: table: attributedata */
switch( nName )
{
/* attributes to be ignored */
case NS_rtf::LN_UNUSED4:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED8:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED1_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED1_7:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED8_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWRITERESERVATION:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FFAREAST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRYPTO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_NFIBBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LKEY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_ENVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWORD97SAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTECHP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTEPAP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTELVC_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CBMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CCPMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWLOWDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWHIGHDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_rtf::LN_ISTD: //index of applied style
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//search for the style with the given id and apply it
//as CharStyleName or ParaStyleName
//if the style is a user defined style then it must have an ISTD - built-in styles might not have it
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
::rtl::OUString sValue = ::rtl::OUString::valueOf(nIntValue, 16);
const StyleSheetEntry* pEntry = pStyleSheets->FindStyleSheetByISTD(sValue);
if(pEntry)
{
bool bParaStyle = (pEntry->nStyleTypeCode == STYLE_TYPE_PARA);
if(bParaStyle)
m_pImpl->SetCurrentParaStyleId(::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16));
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert(
bParaStyle ?
PROP_PARA_STYLE_NAME : PROP_CHAR_STYLE_NAME,
true,
uno::makeAny(
m_pImpl->GetStyleSheetTable()->ConvertStyleName( pEntry->sStyleName ) ) );
}
}
break;
case NS_rtf::LN_ISTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NFC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FLEGAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FNORESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPREV:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPREVSPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FWORD6:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED5_7:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGBXCHNUMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IXCHFOLLOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXASPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAINDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLCHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LSID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_TPLC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGISTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSIMPLELIST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FRESTARTHDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNSIGNED26_2:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ILVL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFORMATTING:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNSIGNED4_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CLFOLVL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBFFNM1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PRQ:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FTRUETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WWEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CHS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetLNCHS( nIntValue );
}
break;
case NS_rtf::LN_IXCHSZALT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PANOSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STI:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSCRATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FINVALHEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHASUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMASSCOPY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SGC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDBASE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CUPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BCHUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FAUTOREDEF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHIDDEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CSTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBSTDBASEINFILE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTDSTYLENAMESWRITTEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED4_2:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STIMAXWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDMAXFIXEDWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NVERBUILTINNAMESWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGFTCSTANDARDCHPSTSH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WIDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NFIB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NPRODUCT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FDOT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCOMPLEX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FHASPIC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CQUICKSAVES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FENCRYPTED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FWHICHTBLSTM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FREADONLYRECOMMENDED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEXTCHAR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEMPTYSPECIAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDEPAGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FFUTURESAVEDUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FSPARE0:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CHSTABLES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CSW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LIDFE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CLW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTECHP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTEPAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CFCLCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetData( nName, nIntValue );
}
break;
case NS_rtf::LN_FN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSEPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FNMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//section descriptor, unused or internally used
break;
case NS_rtf::LN_ICOFORE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICOBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IPAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDFORECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDBACKCOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDPATTERN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTLINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTSPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSHADOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED2_15:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFIRSTMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBACKWARD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FROTATEFONT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTMERGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTRESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_VERTALIGN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
(void)nLineDistance;
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nName )
{
case NS_rtf::LN_BRCTOP:
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCLEFT:
// eBorderId = PROP_LEFT_BORDER;
// eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_rtf::LN_BRCBOTTOM:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCRIGHT:
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
default:;
}
//todo: where to put the border properties
//rContext->Insert(eBorderId, uno::makeAny( aBorderLine ));
//rContext->Insert(eBorderDistId, uno::makeAny( nLineDistance ));
}
break;
case NS_rtf::LN_ITCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPUB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ITCLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FCOL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_YEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_HMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBHEADER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MFP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BM_RCWINMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAMEEMPTY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBITMAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FDRAWHATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FERROR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BPP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CPROPS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSHORIZONTAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_endnote:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BOOKMARKNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// sStringValue contains the bookmark name
sLocalBookmarkName = sStringValue;
break;
case NS_rtf::LN_IBKL:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0.5 */
//contains the bookmark identifier - has to be added to the bookmark name imported before
//if it is already available then the bookmark should be inserted
m_pImpl->AddBookmark( sLocalBookmarkName, sStringValue );
sLocalBookmarkName = ::rtl::OUString();
break;
case NS_rtf::LN_LISTLEVEL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_F:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ALTFONTNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSZFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPXSTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_sed:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//section properties
resolveAttributeProperties(val);
break;
case NS_rtf::LN_tbdAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
{
pProperties->resolve(*this);
//increment to the next tab stop
m_pImpl->NextTabStop();
}
}
break;
case NS_rtf::LN_dxaDel:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//deleted tab
case NS_rtf::LN_dxaAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//set tab
case NS_rtf::LN_TLC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab leading characters - for decimal tabs
case NS_rtf::LN_JC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab justification
m_pImpl->ModifyCurrentTabStop(nName, nIntValue);
break;
case NS_rtf::LN_UNUSED0_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// really unused
break;
case NS_rtf::LN_rgbrc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_shd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellShd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellTopColor:
case NS_rtf::LN_cellLeftColor:
case NS_rtf::LN_cellBottomColor:
case NS_rtf::LN_cellRightColor:
OSL_ASSERT("handled by DomainMapperTableManager");
break;
case NS_rtf::LN_LISTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fcEastAsianLayout:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
/* it seems that the value is following:
???? XX YYYY ZZ
where
XX seems to be the run id
ZZ is the length of the function that is normally 6
Lower byte of YYYY determines whether it is
vertical text flow (0x01), or
two lines in one layout (0x02).
For 0x01, if the higher byte of YYYY is zero, the text is not scaled to fit the line height,
in oposite case, it is to be scaled.
For 0x02, the higher byte of YYYY is determinig the prefix and suffix of the run:
no brackets (0x00) ,
() round brackets (0x01),
[] square backets (0x02),
<> angle brackets (0x03) and
{} curly brackets (0x04).
???? is different and we do not know its signification
*/
if ((nIntValue & 0x000000FF) == 6)
{
switch ((nIntValue & 0x0000FF00) >> 8)
{
case 1: // vertical text
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( sal_Int16(900) ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny (((nIntValue & 0x00FF0000) >> 16) != 0));
}
break;
case 2: // two lines in one
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( true ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16)));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16, false)));
}
break;
default:
break;
}
}
break;
case NS_rtf::LN_FRD :
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnote reference descriptor, if nIntValue > 0 then automatic, custom otherwise
//ignored
break;
case NS_rtf::LN_FONT: //font of footnote symbol
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteFontId( nIntValue );
break;
case NS_ooxml::LN_CT_Sym_char:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
m_pImpl->GetTopContext()->GetFootnote()->setLabel(::rtl::OUString( sal_Unicode(nIntValue)));
break;
}
else //it's a _real_ symbol
{
utext( reinterpret_cast < const sal_uInt8 * >( &nIntValue ), 1 );
}
break;
case NS_rtf::LN_CHAR: //footnote symbol character
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteSymbol( sal_Unicode(nIntValue));
break;
case NS_ooxml::LN_CT_Sym_font:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//the footnote symbol and font are provided after the footnote is already inserted
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
uno::Reference< beans::XPropertySet > xAnchorProps( m_pImpl->GetTopContext()->GetFootnote()->getAnchor(), uno::UNO_QUERY );
xAnchorProps->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_CHAR_FONT_NAME),
uno::makeAny( sStringValue ));
}
else //a real symbol
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Underline_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
handleUnderlineType(nIntValue, m_pImpl->GetTopContext());
break;
case NS_ooxml::LN_CT_Color_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nIntValue ) );
break;
case NS_ooxml::LN_CT_Underline_color:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nIntValue ) );
}
break;
case NS_ooxml::LN_CT_TabStop_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_ST_TabJc_clear)
m_pImpl->m_aCurrentTabStop.bDeleted = true;
else
{
m_pImpl->m_aCurrentTabStop.bDeleted = false;
m_pImpl->m_aCurrentTabStop.Alignment = getTabAlignFromValue(nIntValue);
}
break;
case NS_ooxml::LN_CT_TabStop_leader:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.FillChar = getFillCharFromValue(nIntValue);
break;
case NS_ooxml::LN_CT_TabStop_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.Position = ConversionHelper::convertTwipToMM100(nIntValue);
break;
case NS_ooxml::LN_CT_Fonts_ascii:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_asciiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Fonts_hAnsi:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;//unsupported
case NS_ooxml::LN_CT_Fonts_hAnsiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break; //unsupported
case NS_ooxml::LN_CT_Fonts_eastAsia:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_ASIAN, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_eastAsiaTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ) );
break;
case NS_ooxml::LN_CT_Fonts_cs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_cstheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Spacing_before:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_beforeLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_after:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_afterLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_line: //91434
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Spacing_lineRule: //91435
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
#define SINGLE_LINE_SPACING 240
style::LineSpacing aSpacing;
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
PropertyMap::iterator aLineSpacingIter = pTopContext->find(PropertyDefinition( PROP_PARA_LINE_SPACING, true ) );
if( aLineSpacingIter != pTopContext->end())
{
aLineSpacingIter->second >>= aSpacing;
}
else
{
//default to single line spacing
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
if( nName == NS_ooxml::LN_CT_Spacing_line )
{
//now set the value depending on the Mode
if( aSpacing.Mode == style::LineSpacingMode::PROP )
aSpacing.Height = sal_Int16(sal_Int32(nIntValue) * 100 / SINGLE_LINE_SPACING );
else
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( nIntValue ));
}
else //NS_ooxml::LN_CT_Spacing_lineRule:
{
// exactly, atLeast, auto
if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_auto)
{
aSpacing.Mode = style::LineSpacingMode::PROP;
//reinterpret the already set value
aSpacing.Height = sal_Int16( aSpacing.Height * 100 / ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
else if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_atLeast)
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
else // NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_exact
aSpacing.Mode = style::LineSpacingMode::FIX;
}
pTopContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case NS_ooxml::LN_CT_Ind_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_LEFT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_RIGHT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_hanging:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( - ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_firstLine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_EastAsianLayout_combine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( nIntValue ? true : false ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_combineBrackets:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
rtl::OUString sCombinePrefix = getBracketStringFromEnum(nIntValue);
rtl::OUString sCombineSuffix = getBracketStringFromEnum(nIntValue, false);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( sCombinePrefix ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( sCombineSuffix ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vert:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
sal_Int16 nRotationAngle = (nIntValue ? 900 : 0);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( nRotationAngle ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vertCompress:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny ( nIntValue ? true : false));
break;
case NS_ooxml::LN_CT_PageSz_code:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = nIntValue;
break;
case NS_ooxml::LN_CT_PageSz_h:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.h = PaperInfo::sloppyFitPageDimension(nHeight);
}
break;
case NS_ooxml::LN_CT_PageSz_orient:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.orient = (nIntValue != 0);
break;
case NS_ooxml::LN_CT_PageSz_w:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.w = PaperInfo::sloppyFitPageDimension(nWidth);
}
break;
case NS_ooxml::LN_CT_PageMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_TOP, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_RIGHT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_BOTTOM, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_LEFT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_header:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_HEADER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_footer:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_FOOTER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_gutter:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_GUTTER, nIntValue );
break;
case NS_ooxml::LN_CT_Language_val: //90314
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_eastAsia: //90315
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_bidi: //90316
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
LanguageType eLang = MsLangId::convertIsoStringToLanguage( sStringValue );
lang::Locale aLocale = MsLangId::convertLanguageToLocale( eLang );
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(NS_ooxml::LN_CT_Language_val== nName ? PROP_CHAR_LOCALE :
NS_ooxml::LN_CT_Language_eastAsia == nName ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
#define AUTO_PARA_SPACING sal_Int32(49)
case NS_ooxml::LN_CT_Spacing_beforeAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
//and should be set to 0 on start of page
m_pImpl->GetTopContext()->Insert( PROP_TOP_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_Spacing_afterAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
m_pImpl->GetTopContext()->Insert( PROP_BOTTOM_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_SmartTagRun_uri:
case NS_ooxml::LN_CT_SmartTagRun_element:
/* WRITERFILTERSTATUS: done: 0, planned: 1, spent: 0 */
//TODO: add handling of SmartTags
break;
case NS_ooxml::LN_CT_Br_type :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//TODO: attributes for break (0x12) are not supported
break;
case NS_ooxml::LN_CT_Fonts_hint :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
/* assigns script type to ambigous characters, values can be:
NS_ooxml::LN_Value_ST_Hint_default
NS_ooxml::LN_Value_ST_Hint_eastAsia
NS_ooxml::LN_Value_ST_Hint_cs
*/
//TODO: unsupported?
break;
case NS_ooxml::LN_CT_TblCellMar_right: // 92375;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_top: // 92377;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_left: // 92378;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_bottom: // 92379;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//todo: handle cell mar
break;
case NS_rtf::LN_blip: // contains the binary graphic
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_shape:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
{
//looks a bit like a hack - and it is. The graphic import is split into the inline_inline part and
//afterwards the adding of the binary data.
m_pImpl->GetGraphicImport( IMPORT_AS_DETECTED_INLINE )->attribute(nName, val);
m_pImpl->ImportGraphic( val.getProperties(), IMPORT_AS_DETECTED_INLINE );
if( m_pImpl->IsInShapeContext() )
{
//imported text from temporary shape needs to be copied to the real shape
uno::Reference< drawing::XShape > xShape;
val.getAny() >>= xShape;
m_pImpl->CopyTemporaryShapeText( xShape );
}
}
break;
case NS_ooxml::LN_CT_FramePr_dropCap:
case NS_ooxml::LN_CT_FramePr_lines:
case NS_ooxml::LN_CT_FramePr_hAnchor:
case NS_ooxml::LN_CT_FramePr_vAnchor:
case NS_ooxml::LN_CT_FramePr_x:
case NS_ooxml::LN_CT_FramePr_xAlign:
case NS_ooxml::LN_CT_FramePr_y:
case NS_ooxml::LN_CT_FramePr_yAlign:
case NS_ooxml::LN_CT_FramePr_hRule:
case NS_sprm::LN_PWr:
case NS_sprm::LN_PDxaWidth:
case NS_sprm::LN_PWHeightAbs:
case NS_sprm::LN_PDxaFromText:
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
ParagraphProperties* pParaProperties = dynamic_cast< ParagraphProperties*>(m_pImpl->GetTopContext().get());
if( pParaProperties )
{
switch( nName )
{
case NS_ooxml::LN_CT_FramePr_dropCap:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetDropCap( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_lines:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetLines( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_text: //relative to column
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_margin: nIntValue = text::RelOrientation::PAGE_PRINT_AREA; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SethAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_vAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_text: //relative to paragraph
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_margin:nIntValue = text::RelOrientation::PAGE_PRINT_AREA ; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SetvAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_x:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setx( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_xAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_center : nIntValue = text::HoriOrientation::CENTER; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_right : nIntValue = text::HoriOrientation::RIGHT; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_inside : nIntValue = text::HoriOrientation::INSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_outside : nIntValue = text::HoriOrientation::OUTSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_left : nIntValue = text::HoriOrientation::LEFT; break;
default: nIntValue = text::HoriOrientation::NONE;
}
pParaProperties->SetxAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_y:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Sety( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_yAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_top :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inside :nIntValue = text::VertOrientation::TOP; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_center :nIntValue = text::VertOrientation::CENTER;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_bottom :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_outside :nIntValue = text::VertOrientation::BOTTOM;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inline ://todo: what to do with inline - no avail. in WW97 and WW2007
//no break;
default:nIntValue = text::VertOrientation::NONE;
}
pParaProperties->SetyAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hRule:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_exact:
nIntValue = text::SizeType::FIX;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_atLeast:
nIntValue = text::SizeType::MIN;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_auto:
//no break;
default:;
nIntValue = text::SizeType::VARIABLE;
}
pParaProperties->SethRule( nIntValue );
break;
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//should be either LN_Value_wordprocessingml_ST_Wrap_notBeside or LN_Value_wordprocessingml_ST_Wrap_around
OSL_ENSURE( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ||
sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_notBeside,
"wrap not around or not_Beside?");
pParaProperties->SetWrap(sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ?
text::WrapTextMode_DYNAMIC : text::WrapTextMode_NONE );
}
break;
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setw(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Seth(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SethSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetvSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
default:;
}
}
else
{
//TODO: how to handle frame properties at styles
}
}
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TrackChange_author:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineAuthor( sStringValue );
break;
case NS_ooxml::LN_CT_TrackChange_date:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineDate( sStringValue );
break;
case NS_ooxml::LN_CT_Markup_id:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineId( sStringValue );
break;
case NS_ooxml::LN_token:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineToken( nIntValue );
break;
case NS_ooxml::LN_mark_shape:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if( nIntValue )
m_pImpl->PopShapeContext();
else
m_pImpl->PushShapeContext();
break;
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
//line numbering in Writer is a global document setting
//in Word is a section setting
//if line numbering is switched on anywhere in the document it's set at the global settings
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
switch( nName )
{
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nInterval = nIntValue;
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nStartValue = nIntValue; // todo: has to be set at (each) first paragraph
break;
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nDistance = ConversionHelper::convertTwipToMM100( nIntValue );
break;
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page:empty, probably 0,section:1,continuous:2;
aSettings.bRestartAtEachPage = nIntValue < 1;
break;
default:;
}
m_pImpl->SetLineNumberSettings( aSettings );
}
break;
case NS_ooxml::LN_CT_FtnEdnRef_customMarkFollows:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCustomFtnMark( true );
break;
case NS_ooxml::LN_CT_FtnEdnRef_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// footnote or endnote reference id - not needed
case NS_ooxml::LN_CT_Color_themeColor:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeTint:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeShade:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//unsupported
break;
default:
{
#if OSL_DEBUG_LEVEL > 0
::rtl::OString sMessage( "DomainMapper::attribute() - Id: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 16 );
// sMessage += ::rtl::OString(" / ");
// sMessage += ::rtl::OString
// ((*QNameToString::Instance())(nName).c_str());
sMessage += ::rtl::OString(" value: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 16 );
OSL_ENSURE( false, sMessage.getStr()); //
#endif
}
}
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("attribute");
#endif
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm(Sprm & rSprm)
{
if( !m_pImpl->getTableManager().sprm(rSprm))
DomainMapper::sprm( rSprm, m_pImpl->GetTopContext() );
}
/*-- 20.06.2006 09:58:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm( Sprm& rSprm, PropertyMapPtr rContext, SprmType eSprmType )
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("sprm");
dmapper_logger->chars(rSprm.toString());
#endif
OSL_ENSURE(rContext.get(), "PropertyMap has to be valid!");
if(!rContext.get())
return ;
sal_uInt32 nSprmId = rSprm.getId();
//needed for page properties
SectionPropertyMap* pSectionContext = 0;
//the section context is not availabe before the first call of startSectionGroup()
if( !m_pImpl->IsAnyTableImport() )
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_SECTION);
OSL_ENSURE(pContext.get(), "Section context is not in the stack!");
pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() );
}
//TODO: In rtl-paragraphs the meaning of left/right are to be exchanged
bool bExchangeLeftRight = false;
// if( nSprmId == NS_sprm::LN_PJcExtra && AlreadyInRTLPara() )
// bExchangeLeftRight = true;
Value::Pointer_t pValue = rSprm.getValue();
sal_Int32 nIntValue = pValue->getInt();
rtl::OUString sStringValue = pValue->getString();
// printf ( "DomainMapper::sprm(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nSprmId, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
/* WRITERFILTERSTATUS: table: sprmdata */
switch(nSprmId)
{
case 2: // sprmPIstd
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
case 0x4600:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstd - style code
case 3: // "sprmPIstdPermute
case NS_sprm::LN_PIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstdPermute
case NS_sprm::LN_PIncLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIncLvl
case NS_sprm::LN_PJcExtra: // sprmPJc Asian (undocumented)
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PJc: // sprmPJc
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
handleParaJustification(nIntValue, rContext, bExchangeLeftRight);
break;
case NS_sprm::LN_PFSideBySide:
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
break; // sprmPFSideBySide
case NS_sprm::LN_PFKeep: // sprmPFKeep
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
break;
case NS_sprm::LN_PFKeepFollow: // sprmPFKeepFollow
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_KEEP_TOGETHER, true, uno::makeAny( nIntValue ? true : false) );
break;
case NS_sprm::LN_PFPageBreakBefore:
/* WRITERFILTERSTATUS: done: 100, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE ) );
break; // sprmPFPageBreakBefore
case NS_sprm::LN_PBrcl:
break; // sprmPBrcl
case NS_sprm::LN_PBrcp:
break; // sprmPBrcp
case NS_sprm::LN_PIlvl: // sprmPIlvl
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
//todo: Numbering level will be implemented in the near future (OOo 3.0?)
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListLevel( (sal_Int16)nIntValue );
}
else
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny( (sal_Int16)nIntValue ));
break;
case NS_sprm::LN_PIlfo: // sprmPIlfo
/* WRITERFILTERSTATUS: done: 50, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
{
//convert the ListTable entry to a NumberingRules propery and apply it
sal_Int32 nListId = m_pImpl->GetLFOTable()->GetListID( nIntValue );
if(nListId >= 0)
{
ListTablePtr pListTable = m_pImpl->GetListTable();
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListId( nListId );
}
else
rContext->Insert( PROP_NUMBERING_RULES, true,
uno::makeAny(pListTable->GetNumberingRules(nListId)));
//TODO: Merge overwrittern numbering levels from LFO table
}
}
break;
case NS_sprm::LN_PFNoLineNumb: // sprmPFNoLineNumb
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_LINE_NUMBER_COUNT, true, uno::makeAny( nIntValue ? false : true) );
break;
case NS_sprm::LN_PChgTabsPapx: // sprmPChgTabsPapx
/* WRITERFILTERSTATUS: done: 90, planned: 8, spent: 8 */
/* WRITERFILTERSTATUS: comment: bar tab stops a unavailable */
{
// Initialize tab stop vector from style sheet
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
//create a new tab stop property - this is done with the contained properties
resolveSprmProps(rSprm);
//add this property
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case 0x845d: //right margin Asian - undocumented
case 0x845e: //left margin Asian - undocumented
case 16: // sprmPDxaRight - right margin
case NS_sprm::LN_PDxaRight: // sprmPDxaRight - right margin
case 17:
case NS_sprm::LN_PDxaLeft: // sprmPDxaLeft
/* WRITERFILTERSTATUS: done: 50, planned: 5, spent: 1 */
if( NS_sprm::LN_PDxaLeft == nSprmId || 0x17 == nSprmId|| (bExchangeLeftRight && nSprmId == 0x845d) || ( !bExchangeLeftRight && nSprmId == 0x845e))
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_LEFT_MARGIN : PROP_LEFT_MARGIN,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
else if(eSprmType == SPRM_DEFAULT)
rContext->Insert(
PROP_PARA_RIGHT_MARGIN, true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
//TODO: what happens to the right margins in numberings?
break;
case 18: // sprmPNest
case NS_sprm::LN_PNest: // sprmPNest
//not handled in the old WW8 filter
break;
case 0x8460: //first line indent Asian - undocumented
case 19:
case NS_sprm::LN_PDxaLeft1: // sprmPDxaLeft1
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_FIRST_LINE_INDENT : PROP_FIRST_LINE_OFFSET,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case 20 : // sprmPDyaLine
case NS_sprm::LN_PDyaLine: // sprmPDyaLine
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
{
style::LineSpacing aSpacing;
sal_Int16 nDistance = sal_Int16(nIntValue & 0xffff);
if(nIntValue & 0xffff0000)
{
// single line in Writer is 100, in Word it is 240
aSpacing.Mode = style::LineSpacingMode::PROP;
aSpacing.Height = sal_Int16(sal_Int32(nDistance) * 100 /240);
}
else
{
if(nDistance < 0)
{
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(-nDistance));
}
else if(nDistance >0)
{
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(nDistance));
}
}
rContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case 21 : // legacy version
case NS_sprm::LN_PDyaBefore: // sprmPDyaBefore
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 22 :
case NS_sprm::LN_PDyaAfter: // sprmPDyaAfter
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 23: //sprmPChgTabs
case NS_sprm::LN_PChgTabs: // sprmPChgTabs
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
OSL_ENSURE( false, "unhandled");
//tabs of list level?
break;
case 24: // "sprmPFInTable"
case NS_sprm::LN_PFInTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFInTable
case NS_sprm::LN_PTableDepth: //sprmPTableDepth
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//not handled via sprm but via text( 0x07 )
break;
case 25: // "sprmPTtp" pap.fTtp
case NS_sprm::LN_PFTtp: // sprmPFTtp was: Read_TabRowEnd
break;
case 26: // "sprmPDxaAbs
case NS_sprm::LN_PDxaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaAbs
case 27: //sprmPDyaAbs
case NS_sprm::LN_PDyaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaAbs
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaWidth
case NS_sprm::LN_PPc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPc
case NS_sprm::LN_PBrcTop10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcTop10
case NS_sprm::LN_PBrcLeft10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcLeft10
case NS_sprm::LN_PBrcBottom10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBottom10
case NS_sprm::LN_PBrcRight10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcRight10
case NS_sprm::LN_PBrcBetween10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBetween10
case NS_sprm::LN_PBrcBar10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar10
case NS_sprm::LN_PDxaFromText10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText10
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWr
case NS_ooxml::LN_CT_PrBase_pBdr: //paragraph border
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
resolveSprmProps(rSprm);
break;
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: done: 0, planned: 8, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
{
//in binary format the borders are directly provided in OOXML they are inside of properties
if( IsOOXMLImport() )
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
BorderHandlerPtr pBorderHandler( new BorderHandler( true ) );
pProperties->resolve(*pBorderHandler);
PropertyIds eBorderId = PropertyIds( 0 );
PropertyIds eBorderDistId = PropertyIds( 0 );
switch( nSprmId )
{
case NS_sprm::LN_PBrcTop:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcLeft:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcRight:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcBetween:
/* WRITERFILTERSTATUS: */
//not supported
break;
default:;
}
if( eBorderId )
rContext->Insert( eBorderId, true, uno::makeAny( pBorderHandler->getBorderLine()) , true);
if(eBorderDistId)
rContext->Insert(eBorderDistId, true, uno::makeAny( pBorderHandler->getLineDistance()), true);
}
}
else
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nSprmId )
{
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: */
OSL_ENSURE( false, "TODO: inner border is not handled");
break;
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: */
default:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
}
rContext->Insert(eBorderId, true, uno::makeAny( aBorderLine ));
rContext->Insert(eBorderDistId, true, uno::makeAny( nLineDistance ));
}
}
break;
case NS_sprm::LN_PBorderTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
OSL_ENSURE( false, "TODO: border color definition");
break;
case NS_sprm::LN_PBrcBar:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar
case NS_sprm::LN_PFNoAutoHyph: // sprmPFNoAutoHyph
/* WRITERFILTERSTATUS: done: 100, planned: 1, spent: 0 */
rContext->Insert(PROP_PARA_IS_HYPHENATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWHeightAbs
case NS_sprm::LN_PDcs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDcs
case NS_sprm::LN_PShd: // sprmPShd
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 2 */
{
//contains fore color, back color and shadow percentage, results in a brush
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
CellColorHandlerPtr pCellColorHandler( new CellColorHandler );
pCellColorHandler->setParagraph();
pProperties->resolve(*pCellColorHandler);
rContext->insert( pCellColorHandler->getProperties(), true );
}
}
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaFromText
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText
case NS_sprm::LN_PFLocked:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFLocked
case NS_sprm::LN_PFWidowControl:
case NS_ooxml::LN_CT_PPrBase_widowControl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
uno::Any aVal( uno::makeAny( sal_Int8(nIntValue ? 2 : 0 )));
rContext->Insert( PROP_PARA_WIDOWS, true, aVal );
rContext->Insert( PROP_PARA_ORPHANS, true, aVal );
}
break; // sprmPFWidowControl
case NS_sprm::LN_PRuler:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPRuler
case NS_sprm::LN_PFKinsoku:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFKinsoku
case NS_sprm::LN_PFWordWrap:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFWordWrap
case NS_sprm::LN_PFOverflowPunct: ; // sprmPFOverflowPunct - hanging punctuation
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_PARA_IS_HANGING_PUNCTUATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PFTopLinePunct:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFTopLinePunct
case NS_sprm::LN_PFAutoSpaceDE:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDE
case NS_sprm::LN_PFAutoSpaceDN:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDN
case NS_sprm::LN_PWAlignFont:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWAlignFont
case NS_sprm::LN_PFrameTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFrameTextFlow
case NS_sprm::LN_PISnapBaseLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPISnapBaseLine
case NS_sprm::LN_PAnld:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPAnld
case NS_sprm::LN_PPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPropRMark
case NS_sprm::LN_POutLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPOutLvl
case NS_sprm::LN_PFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFBiDi
case NS_sprm::LN_PFNumRMIns:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFNumRMIns
case NS_sprm::LN_PCrLf:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPCrLf
case NS_sprm::LN_PNumRM:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPNumRM
case NS_sprm::LN_PHugePapx:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPHugePapx
case NS_sprm::LN_PFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFUsePgsuSettings
case NS_sprm::LN_PFAdjustRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAdjustRight
case NS_sprm::LN_CFRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMarkDel
case NS_sprm::LN_CFRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMark
case NS_sprm::LN_CFFldVanish:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFldVanish
case NS_sprm::LN_CFSpec: // sprmCFSpec
break;
case NS_sprm::LN_CPicLocation: // sprmCPicLocation
//is being resolved on the tokenizer side
break;
case NS_sprm::LN_CIbstRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMark
case NS_sprm::LN_CDttmRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMark
case NS_sprm::LN_CFData:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFData
case NS_sprm::LN_CIdslRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMark
case NS_sprm::LN_CChs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCChs
case NS_sprm::LN_CSymbol: // sprmCSymbol
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
resolveSprmProps(rSprm); //resolves LN_FONT and LN_CHAR
break;
case NS_sprm::LN_CFOle2:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFOle2
case NS_sprm::LN_CIdCharType:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdCharType
case NS_sprm::LN_CHighlight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if(true ==( mbIsHighlightSet = getColorFromIndex(nIntValue, nColor)))
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( nColor ));
else if (mnBackgroundColor)
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( mnBackgroundColor ));
}
break; // sprmCHighlight
case NS_sprm::LN_CObjLocation:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCObjLocation
case NS_sprm::LN_CFFtcAsciSymb:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFtcAsciSymb
case NS_sprm::LN_CIstd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstd
case NS_sprm::LN_CIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstdPermute
case NS_sprm::LN_CDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDefault
case NS_sprm::LN_CPlain:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPlain
case NS_sprm::LN_CKcd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_EMPHASIS, true, uno::makeAny ( getEmphasisValue (nIntValue)));
break; // sprmCKcd
case NS_sprm::LN_CFEmboss:// sprmCFEmboss
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi:// sprmCFBoldBi (offset 0x27 to normal bold)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalicBi:// sprmCFItalicBi (offset 0x27 to normal italic)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFBold: //sprmCFBold
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 61: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalic: //sprmCFItalic
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFStrike: //sprmCFStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5*/
case NS_sprm::LN_CFOutline: //sprmCFOutline
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFShadow: //sprmCFShadow
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFSmallCaps: //sprmCFSmallCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFCaps: //sprmCFCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFVanish: //sprmCFVanish
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFDStrike: // sprmCFDStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
{
PropertyIds ePropertyId = PROP_CHAR_WEIGHT; //initialized to prevent warning!
switch( nSprmId )
{
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
case NS_sprm::LN_CFBold: /*sprmCFBold*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId != NS_sprm::LN_CFBoldBi ? PROP_CHAR_WEIGHT : PROP_CHAR_WEIGHT_COMPLEX;
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId == 0x836 ? PROP_CHAR_POSTURE : PROP_CHAR_POSTURE_COMPLEX;
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_STRIKEOUT;
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CONTOURED;
break;
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_SHADOWED;
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CASE_MAP;
break;
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_HIDDEN;
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_RELIEF;
break;
}
//expected: 0,1,128,129
if(nIntValue != 128) //inherited from paragraph - ignore
{
if( nIntValue == 129) //inverted style sheet value
{
//get value from style sheet and invert it
sal_Int16 nStyleValue = 0;
double fDoubleValue;
uno::Any aStyleVal = m_pImpl->GetPropertyFromStyleSheet(ePropertyId);
if( !aStyleVal.hasValue() )
{
nIntValue = 0x83a == nSprmId ?
4 : 1;
}
else if(aStyleVal.getValueTypeClass() == uno::TypeClass_FLOAT )
{
//only in case of awt::FontWeight
aStyleVal >>= fDoubleValue;
nIntValue = fDoubleValue > 100. ? 0 : 1;
}
else if((aStyleVal >>= nStyleValue) ||
(nStyleValue = (sal_Int16)comphelper::getEnumAsINT32(aStyleVal)) >= 0 )
{
nIntValue = 0x83a == nSprmId ?
nStyleValue ? 0 : 4 :
nStyleValue ? 0 : 1;
}
else
{
OSL_ENSURE( false, "what type was it");
}
}
switch( nSprmId )
{
case 60:/*sprmCFBold*/
case NS_sprm::LN_CFBold: /*sprmCFBold*/
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
/* WRITERFILTERSTATUS: */
{
uno::Any aBold( uno::makeAny( nIntValue ? awt::FontWeight::BOLD : awt::FontWeight::NORMAL ) );
rContext->Insert(ePropertyId, true, aBold );
if( nSprmId != NS_sprm::LN_CFBoldBi ) // sprmCFBoldBi
rContext->Insert(PROP_CHAR_WEIGHT_ASIAN, true, aBold );
}
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
/* WRITERFILTERSTATUS: */
{
uno::Any aPosture( uno::makeAny( nIntValue ? awt::FontSlant_ITALIC : awt::FontSlant_NONE ) );
rContext->Insert( ePropertyId, true, aPosture );
if( nSprmId != NS_sprm::LN_CFItalicBi ) // sprmCFItalicBi
rContext->Insert(PROP_CHAR_POSTURE_ASIAN, true, aPosture );
}
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontStrikeout::SINGLE : awt::FontStrikeout::NONE ) );
break;
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( awt::FontStrikeout::DOUBLE ) );
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true, uno::makeAny( nIntValue ? true : false ));
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::SMALLCAPS : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::UPPERCASE : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontRelief::EMBOSSED : awt::FontRelief::NONE ));
break;
}
}
}
break;
case NS_sprm::LN_CFtcDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFtcDefault
case NS_sprm::LN_CKul: // sprmCKul
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
// Parameter: 0 = none, 1 = single, 2 = by Word,
// 3 = double, 4 = dotted, 5 = hidden
// 6 = thick, 7 = dash, 8 = dot(not used)
// 9 = dotdash 10 = dotdotdash 11 = wave
handleUnderlineType(nIntValue, rContext);
}
break;
case NS_sprm::LN_CSizePos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCSizePos
case NS_sprm::LN_CLid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCLid
case NS_sprm::LN_CIco:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if (getColorFromIndex(nIntValue, nColor))
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break; // sprmCIco
case NS_sprm::LN_CHpsBi: // sprmCHpsBi
case NS_sprm::LN_CHps: // sprmCHps
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//multiples of half points (12pt == 24)
double fVal = double(nIntValue) / 2.;
uno::Any aVal = uno::makeAny( fVal );
if( NS_sprm::LN_CHpsBi == nSprmId )
rContext->Insert( PROP_CHAR_HEIGHT_COMPLEX, true, aVal );
else
{
//Asian get the same value as Western
rContext->Insert( PROP_CHAR_HEIGHT, true, aVal );
rContext->Insert( PROP_CHAR_HEIGHT_ASIAN, true, aVal );
}
}
break;
case NS_sprm::LN_CHpsInc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc
case NS_sprm::LN_CHpsPos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
// FIXME: ww8 filter in ww8par6.cxx has a Read_SubSuperProp function
// that counts the escapement from this value and font size. So it will be
// on our TODO list
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 100;
if (nIntValue < 0)
nEscapement = -58;
else if (nIntValue > 0)
nEscapement = 58;
else /* (nIntValue == 0) */
nProp = 0;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break; // sprmCHpsPos
case NS_sprm::LN_CHpsPosAdj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsPosAdj
case NS_sprm::LN_CMajority:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority
case NS_sprm::LN_CIss: // sprmCIss
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//sub/super script 1: super, 2: sub, 0: normal
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
switch(nIntValue)
{
case 1: //super
nEscapement = 101;
break;
case 2: //sub
nEscapement = -101;
break;
case 0: nProp = 0;break; //none
}
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
case NS_sprm::LN_CHpsNew50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsNew50
case NS_sprm::LN_CHpsInc1:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc1
case 71 : //"sprmCDxaSpace"
case 96 : //"sprmCDxaSpace"
case NS_sprm::LN_CDxaSpace: // sprmCDxaSpace
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
//Kerning half point values
//TODO: there are two kerning values -
// in ww8par6.cxx NS_sprm::LN_CHpsKern is used as boolean AutoKerning
rContext->Insert(PROP_CHAR_CHAR_KERNING, true, uno::makeAny( sal_Int16(ConversionHelper::convertTwipToMM100(sal_Int16(nIntValue))) ) );
break;
case NS_sprm::LN_CHpsKern: // sprmCHpsKern auto kerning is bound to a minimum font size in Word - but not in Writer :-(
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_AUTO_KERNING, true, uno::makeAny( true ) );
break;
case NS_sprm::LN_CMajority50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority50
case NS_sprm::LN_CHpsMul:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsMul
case NS_sprm::LN_CYsri:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCYsri
case NS_sprm::LN_CRgFtc0: // sprmCRgFtc0 //ascii font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc1: // sprmCRgFtc1 //Asian font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc2: // sprmCRgFtc2 //CTL font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CFtcBi: // sprmCFtcBi //font index of a CTL font
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
FontTablePtr pFontTable = m_pImpl->GetFontTable();
if(nIntValue >= 0 && pFontTable->size() > sal_uInt32(nIntValue))
{
PropertyIds eFontName = PROP_CHAR_FONT_NAME;
PropertyIds eFontStyle = PROP_CHAR_FONT_STYLE;
PropertyIds eFontFamily = PROP_CHAR_FONT_FAMILY;
PropertyIds eFontCharSet = PROP_CHAR_FONT_CHAR_SET;
PropertyIds eFontPitch = PROP_CHAR_FONT_PITCH;
switch(nSprmId)
{
case NS_sprm::LN_CRgFtc0:
//already initialized
break;
case NS_sprm::LN_CRgFtc1:
eFontName = PROP_CHAR_FONT_NAME_ASIAN;
eFontStyle = PROP_CHAR_FONT_STYLE_ASIAN;
eFontFamily = PROP_CHAR_FONT_FAMILY_ASIAN;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_ASIAN;
eFontPitch = PROP_CHAR_FONT_PITCH_ASIAN;
break;
case NS_sprm::LN_CRgFtc2:
case NS_sprm::LN_CFtcBi:
eFontName = PROP_CHAR_FONT_NAME_COMPLEX;
eFontStyle = PROP_CHAR_FONT_STYLE_COMPLEX;
eFontFamily = PROP_CHAR_FONT_FAMILY_COMPLEX;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_COMPLEX;
eFontPitch = PROP_CHAR_FONT_PITCH_COMPLEX;
break;
}
const FontEntry* pFontEntry = pFontTable->getFontEntry(sal_uInt32(nIntValue));
rContext->Insert(eFontName, true, uno::makeAny( pFontEntry->sFontName ));
// rContext->Insert(eFontStyle, uno::makeAny( pFontEntry-> ));
// rContext->Insert(eFontFamily, uno::makeAny( pFontEntry-> ));
rContext->Insert(eFontCharSet, true, uno::makeAny( (sal_Int16)pFontEntry->nTextEncoding ));
rContext->Insert(eFontPitch, true, uno::makeAny( pFontEntry->nPitchRequest ));
}
}
break;
case NS_sprm::LN_CCharScale: // sprmCCharScale
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_SCALE_WIDTH, true,
uno::makeAny( sal_Int16(nIntValue) ));
break;
case NS_sprm::LN_CFImprint: // sprmCFImprint 1 or 0
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
// FontRelief: NONE, EMBOSSED, ENGRAVED
rContext->Insert(PROP_CHAR_RELIEF, true,
uno::makeAny( nIntValue ? awt::FontRelief::ENGRAVED : awt::FontRelief::NONE ));
break;
case NS_sprm::LN_CFObj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFObj
case NS_sprm::LN_CPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPropRMark
case NS_sprm::LN_CSfxText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// The file-format has many character animations. We have only
// one, so we use it always. Suboptimal solution though.
if (nIntValue)
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( true ));
else
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( false ));
break; // sprmCSfxText
case NS_sprm::LN_CFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFBiDi
case NS_sprm::LN_CFDiacColor:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFDiacColor
case NS_sprm::LN_CIcoBi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIcoBi
case NS_sprm::LN_CDispFldRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDispFldRMark
case NS_sprm::LN_CIbstRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMarkDel
case NS_sprm::LN_CDttmRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMarkDel
case NS_sprm::LN_CBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCBrc
case NS_sprm::LN_CShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCShd
case NS_sprm::LN_CIdslRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMarkDel
case NS_sprm::LN_CFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFUsePgsuSettings
case NS_sprm::LN_CCpg:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCCpg
case NS_sprm::LN_CLidBi: // sprmCLidBi language complex
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case 0x4873: //sprmCRgLid
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 1 */
//undocumented but interpreted as western language
case NS_sprm::LN_CRgLid0: // sprmCRgLid0 language Western
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid1: // sprmCRgLid1 language Asian
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
lang::Locale aLocale;
MsLangId::convertLanguageToLocale( (LanguageType)nIntValue, aLocale );
rContext->Insert(NS_sprm::LN_CRgLid0 == nSprmId ? PROP_CHAR_LOCALE :
NS_sprm::LN_CRgLid1 == nSprmId ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
case NS_sprm::LN_CIdctHint: // sprmCIdctHint
//list table - text offset???
break;
case NS_sprm::LN_PicBrcl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcl
case NS_sprm::LN_PicScale:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicScale
case NS_sprm::LN_PicBrcTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcTop
case NS_sprm::LN_PicBrcLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcLeft
case NS_sprm::LN_PicBrcBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcBoConversionHelper::convertTwipToMM100ttom
case NS_sprm::LN_PicBrcRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcRight
case NS_sprm::LN_ScnsPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmScnsPgn
case NS_sprm::LN_SiHeadingPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSiHeadingPgn
case NS_sprm::LN_SOlstAnm:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSOlstAnm
case 136:
case NS_sprm::LN_SDxaColWidth: // sprmSDxaColWidth
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// contains the twip width of the column as 3-byte-code
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnWidth( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case NS_sprm::LN_SDxaColSpacing: // sprmSDxaColSpacing
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnSpacing( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case 138:
case NS_sprm::LN_SFEvenlySpaced:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSFEvenlySpaced
case NS_sprm::LN_SFProtected: // sprmSFProtected
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
//todo: missing feature - unlocked sections in protected documents
break;
case NS_sprm::LN_SDmBinFirst: // sprmSDmBinFirst
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetFirstPaperBin(nIntValue);
break;
case NS_sprm::LN_SDmBinOther: // sprmSDmBinOther
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPaperBin( nIntValue );
break;
case NS_sprm::LN_SBkc: // sprmSBkc
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
/* break type
0 - No break
1 - New Colunn
2 - New page
3 - Even page
4 - odd page
*/
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBreakType( nIntValue );
break;
case 143:
case NS_sprm::LN_SFTitlePage: // sprmSFTitlePage
case NS_ooxml::LN_EG_SectPrContents_titlePg:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTitlePage( nIntValue > 0 ? true : false );//section has title page
}
break;
case 144:
case NS_sprm::LN_SCcolumns: // sprmSCcolumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//no of columns - 1
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnCount( (sal_Int16) nIntValue );
break;
case 145:
case NS_sprm::LN_SDxaColumns: // sprmSDxaColumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//column distance - default 708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnDistance( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case NS_sprm::LN_SFAutoPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFAutoPgn
case 147:
case NS_sprm::LN_SNfcPgn: // sprmSNfcPgn
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//page numbering 0 - Arab, 1 - ROMAN, 2 - roman, 3 - ABC, 4 abc
sal_Int16 nNumbering;
switch( nIntValue )
{
case 1: nNumbering = style::NumberingType::ROMAN_UPPER;
case 2: nNumbering = style::NumberingType::ROMAN_LOWER;
case 3: nNumbering = style::NumberingType::CHARS_UPPER_LETTER;
case 4: nNumbering = style::NumberingType::CHARS_LOWER_LETTER;
case 0:
default:
nNumbering = style::NumberingType::ARABIC;
}
rContext->Insert( PROP_NUMBERING_TYPE, false, uno::makeAny( nNumbering ) );
break;
case NS_sprm::LN_SDyaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDyaPgn
case NS_sprm::LN_SDxaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDxaPgn
case 150:
case NS_sprm::LN_SFPgnRestart: // sprmSFPgnRestart
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNoRestart( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFEndnote:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFEndnote
case 154:
case NS_sprm::LN_SNLnnMod:// sprmSNLnnMod
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMod( nIntValue );
break;
case 155:
case NS_sprm::LN_SDxaLnn: // sprmSDxaLnn
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetdxaLnn( nIntValue );
break;
case 152:
case NS_sprm::LN_SLnc:// sprmSLnc
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnc( nIntValue );
break;
case 160:
case NS_sprm::LN_SLnnMin: // sprmSLnnMin
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMin( nIntValue );
break;
case NS_sprm::LN_SGprfIhdt:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
//flags about header/footer sharing and footnotes?
/* ww8scan.hxx:
* WW8_HEADER_EVEN = 0x01, WW8_HEADER_ODD = 0x02, WW8_FOOTER_EVEN = 0x04,
* WW8_FOOTER_ODD = 0x08, WW8_HEADER_FIRST = 0x10, WW8_FOOTER_FIRST = 0x20
*/
// if(pSectionContext)
break; // sprmSGprfIhdt
case NS_sprm::LN_SDyaHdrTop: // sprmSDyaHdrTop
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderTop( ConversionHelper::convertTwipToMM100( nIntValue ));
break;
case NS_sprm::LN_SDyaHdrBottom: // sprmSDyaHdrBottom
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderBottom( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case 158:
case NS_sprm::LN_SLBetween: // sprmSLBetween
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSeparatorLine( nIntValue > 0 );
break;
case NS_sprm::LN_SVjc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSVjc
case 161:
case NS_sprm::LN_SPgnStart: // sprmSPgnStart
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page number
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNumber( nIntValue );
break;
case 162:
case NS_sprm::LN_SBOrientation:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//todo: the old filter assumed that a value of 2 points to double-pages layout
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetLandscape( nIntValue > 0 );
rContext->Insert( PROP_IS_LANDSCAPE , false, uno::makeAny( nIntValue > 0 ));
break; // sprmSBOrientation
case NS_sprm::LN_SBCustomize:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSBCustomize
case 165:
case NS_sprm::LN_SYaPage: // sprmSYaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page height, rounded to default values, default: 0x3dc0 twip
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_HEIGHT, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nHeight ) ) );
}
break;
case NS_sprm::LN_SXaPage: // sprmSXaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page width, rounded to default values, default 0x2fd0 twip
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_WIDTH, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nWidth ) ) );
}
break;
case 166:
case NS_sprm::LN_SDxaLeft: // sprmSDxaLeft
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//left page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetLeftMargin( nConverted );
rContext->Insert( PROP_LEFT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 167:
case NS_sprm::LN_SDxaRight: // sprmSDxaRight
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//right page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetRightMargin( nConverted );
rContext->Insert( PROP_RIGHT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 168:
case NS_sprm::LN_SDyaTop: // sprmSDyaTop
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//top page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_TOP_MARGIN, false, uno::makeAny( nConverted ) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTopMargin( nConverted );
}
break;
case 169:
case NS_sprm::LN_SDyaBottom: // sprmSDyaBottom
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//bottom page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_BOTTOM_MARGIN, false, uno::makeAny( nConverted) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBottomMargin( nConverted );
}
break;
case 170:
case NS_sprm::LN_SDzaGutter: // sprmSDzaGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// gutter is added to one of the margins of a section depending on RTL, can be placed on top either
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDzaGutter( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case NS_sprm::LN_SDmPaperReq: // sprmSDmPaperReq
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//paper code - no handled in old filter
break;
case NS_sprm::LN_SPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSPropRMark
case NS_sprm::LN_SFBiDi:// sprmSFBiDi
{
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSFBiDi( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFFacingCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFFacingCol
case NS_sprm::LN_SFRTLGutter: // sprmSFRTLGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetGutterRTL( nIntValue > 0 );
}
break;
case NS_sprm::LN_SBrcTop: // sprmSBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcLeft: // sprmSBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcBottom: // sprmSBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcRight: // sprmSBrcRight
/* WRITERFILTERSTATUS: Sectiondone: 100, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
static const BorderPosition aPositions[4] =
{
BORDER_TOP,
BORDER_LEFT,
BORDER_BOTTOM,
BORDER_RIGHT
};
pSectionContext->SetBorder( aPositions[nSprmId - NS_sprm::LN_SBrcTop], nLineDistance, aBorderLine );
}
}
break;
case NS_sprm::LN_SPgbProp: // sprmSPgbProp
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->ApplyBorderToPageStyles( m_pImpl->GetPageStyles(), m_pImpl->GetTextFactory(), nIntValue );
}
}
break;
case NS_sprm::LN_SDxtCharSpace:
{
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDxtCharSpace( nIntValue );
}
}
break; // sprmSDxtCharSpace
case NS_sprm::LN_SDyaLinePitch: // sprmSDyaLinePitch
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//see SwWW8ImplReader::SetDocumentGrid
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetGridLinePitch( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case 0x703a: //undocumented, grid related?
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE( false, "TODO: not handled yet"); //nIntValue like 0x008a2373 ?
break;
case NS_sprm::LN_SClm:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
sal_Int16 nGridType = text::TextGridMode::NONE;
switch( nIntValue )
{
case 0:
nGridType = text::TextGridMode::NONE;
break;
case 3:
//Text snaps to char grid, this doesn't make a lot of sense to
//me. This is closer than LINES_CHARS
nGridType = text::TextGridMode::LINES;
break;
case 1:
nGridType = text::TextGridMode::LINES_AND_CHARS;
break;
case 2:
nGridType = text::TextGridMode::LINES;
break;
default:;
}
rContext->Insert( PROP_GRID_MODE, false, uno::makeAny( nGridType ) );
//Seems to force this behaviour in word ?
if(nGridType != text::TextGridMode::NONE)
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_EXTERNAL_LEADING ),
uno::makeAny( true ) );
}
break; // sprmSClm
case NS_sprm::LN_STextFlow:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* 0 HoriLR 1 Vert TR 2 Vert TR 3 Vert TT 4 HoriLT
only 0 and 1 can be imported correctly
*/
sal_Int16 nDirection = text::WritingMode_LR_TB;
switch( nIntValue )
{
case 0:
case 4:
nDirection = text::WritingMode_LR_TB;
break;
case 1:
case 2:
case 3:
nDirection = text::WritingMode_TB_RL;
break;
default:;
}
rContext->Insert(PROP_WRITING_MODE, false, uno::makeAny( nDirection ) );
}
break; // sprmSTextFlow
case NS_sprm::LN_TJc: // sprmTJc
case NS_sprm::LN_TDxaLeft:
case NS_sprm::LN_TDxaGapHalf:
case NS_sprm::LN_TFCantSplit:
case NS_sprm::LN_TTableHeader:
case NS_sprm::LN_TTableBorders: // sprmTTableBorders
{
OSL_ENSURE( false, "table propeties should be handled by the table manager");
}
break;
case NS_sprm::LN_TDefTable10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable10
case NS_sprm::LN_TDyaRowHeight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDyaRowHeight
case NS_sprm::LN_TDefTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable
case NS_sprm::LN_TDefTableShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTableShd
case NS_sprm::LN_TTlp:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTlp
case NS_sprm::LN_TFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTFBiDi
case NS_sprm::LN_THTMLProps:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTHTMLProps
case NS_sprm::LN_TSetBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc
case NS_sprm::LN_TInsert:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTInsert
case NS_sprm::LN_TDelete:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDelete
case NS_sprm::LN_TDxaCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDxaCol
case NS_sprm::LN_TMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTMerge
case NS_sprm::LN_TSplit:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSplit
case NS_sprm::LN_TSetBrc10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc10
case 164: // sprmTSetShd
case NS_sprm::LN_TSetShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShd
case NS_sprm::LN_TSetShdOdd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShdOdd
case NS_sprm::LN_TTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTextFlow
case NS_sprm::LN_TDiagLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDiagLine
case NS_sprm::LN_TVertMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertMerge
case NS_sprm::LN_TVertAlign:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertAlign
// the following are not part of the official documentation
case 0x6870: //TxtForeColor
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//contains a color as 0xTTRRGGBB while SO uses 0xTTRRGGBB
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x4874:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //seems to be a language id for Asian text - undocumented
case 0x6877: //underlining color
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
rContext->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x6815:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case NS_sprm::LN_CIndrsid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x6467:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xF617:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xd634: // sprmTNewSpacing - table spacing ( see WW8TabBandDesc::ProcessSpacing() )
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break;
case NS_sprm::LN_TTRLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x4888:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0x6887:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//properties of list levels - undocumented
break;
case 0xd234:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd235:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd236:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd237:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;//undocumented section properties
case NS_sprm::LN_CEastAsianLayout:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_CT_Tabs_tab:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
m_pImpl->IncorporateTabStop(m_pImpl->m_aCurrentTabStop);
m_pImpl->m_aCurrentTabStop = DeletableTabStop();
break;
case NS_ooxml::LN_CT_PPrBase_tabs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
// Initialize tab stop vector from style sheet
if( !m_pImpl->IsStyleSheetImport() )
{
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
}
resolveSprmProps(rSprm);
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case NS_ooxml::LN_CT_PPr_sectPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_color:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_rFonts:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_bdr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_eastAsianLayout:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_u:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_lang:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_spacing:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_ind:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_RPrDefault_rPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrDefault_pPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_pPrDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_rPrDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_pPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_rPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPr_rPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_numPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_footnotePr:
/* WRITERFILTERSTATUS: done: 1ß0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_SectPrContents_endnotePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetInFootnoteProperties( NS_ooxml::LN_EG_SectPrContents_footnotePr == nSprmId );
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_lnNumType:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
aSettings.bIsOn = true;
m_pImpl->SetLineNumberSettings( aSettings );
//apply settings at XLineNumberingProperties
try
{
uno::Reference< text::XLineNumberingProperties > xLineNumberingProperties( m_pImpl->GetTextDocument(), uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySet > xLineNumberingPropSet = xLineNumberingProperties->getLineNumberingProperties();
PropertyNameSupplier& rNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_IS_ON ), uno::makeAny(true) );
if( aSettings.nInterval )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_INTERVAL ), uno::makeAny((sal_Int16)aSettings.nInterval) );
if( aSettings.nDistance )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_DISTANCE ), uno::makeAny(aSettings.nDistance) );
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_RESTART_AT_EACH_PAGE ), uno::makeAny(aSettings.bRestartAtEachPage) );
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_CT_PPrBase_framePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pContext.get() )
{
ParagraphPropertyMap* pParaContext = dynamic_cast< ParagraphPropertyMap* >( pContext.get() );
pParaContext->SetFrameMode();
}
else
{
//TODO: What about style sheet import of frame properties
}
resolveSprmProps(rSprm);
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgSz:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = 0;
{
PaperInfo aLetter(PAPER_LETTER);
CT_PageSz.w = aLetter.getWidth();
CT_PageSz.h = aLetter.getHeight();
}
CT_PageSz.orient = false;
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->Insert( PROP_HEIGHT, false, uno::makeAny( CT_PageSz.h ) );
pSectionContext->Insert( PROP_IS_LANDSCAPE, false, uno::makeAny( CT_PageSz.orient ));
pSectionContext->Insert( PROP_WIDTH, false, uno::makeAny( CT_PageSz.w ) );
pSectionContext->SetLandscape( CT_PageSz.orient );
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgMar:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->InitPageMargins();
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
const _PageMar& rPageMar = m_pImpl->GetPageMargins();
pSectionContext->SetTopMargin( rPageMar.top );
pSectionContext->SetRightMargin( rPageMar.right );
pSectionContext->SetBottomMargin( rPageMar.bottom );
pSectionContext->SetLeftMargin( rPageMar.left );
pSectionContext->SetHeaderTop( rPageMar.header );
pSectionContext->SetHeaderBottom( rPageMar.footer );
}
break;
case NS_ooxml::LN_EG_SectPrContents_cols:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
SectionColumnHandlerPtr pSectHdl( new SectionColumnHandler );
pProperties->resolve(*pSectHdl);
if(pSectionContext)
{
if( pSectHdl->IsEqualWidth() )
{
pSectionContext->SetEvenlySpaced( true );
pSectionContext->SetColumnCount( (sal_Int16) (pSectHdl->GetNum() - 1) );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( !pSectHdl->GetColumns().empty() )
{
pSectionContext->SetEvenlySpaced( false );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetColumnCount( (sal_Int16)(pSectHdl->GetColumns().size() -1));
std::vector<_Column>::const_iterator tmpIter = pSectHdl->GetColumns().begin();
for (; tmpIter != pSectHdl->GetColumns().end(); tmpIter++)
{
pSectionContext->AppendColumnWidth( tmpIter->nWidth );
if ((tmpIter != pSectHdl->GetColumns().end() - 1) || (tmpIter->nSpace > 0))
pSectionContext->AppendColumnSpacing( tmpIter->nSpace );
}
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( pSectHdl->GetNum() > 0 )
{
pSectionContext->SetColumnCount( (sal_Int16)pSectHdl->GetNum() - 1 );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
}
}
}
}
break;
case NS_ooxml::LN_CT_PPrBase_pStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
m_pImpl->SetCurrentParaStyleId( sStringValue );
StyleSheetTablePtr pStyleTable = m_pImpl->GetStyleSheetTable();
const ::rtl::OUString sConvertedStyleName = pStyleTable->ConvertStyleName( sStringValue, true );
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sConvertedStyleName ));
const StyleSheetEntry* pEntry = pStyleTable->FindStyleSheetByISTD(sStringValue);
//apply numbering to paragraph if it was set at the style
OSL_ENSURE( pEntry, "no style sheet found" );
const StyleSheetPropertyMap* pStyleSheetProperties = dynamic_cast<const StyleSheetPropertyMap*>(pEntry ? pEntry->pProperties.get() : 0);
if( pStyleSheetProperties && pStyleSheetProperties->GetListId() >= 0 )
rContext->Insert( PROP_NUMBERING_RULES, true, uno::makeAny(m_pImpl->GetListTable()->GetNumberingRules(pStyleSheetProperties->GetListId())), false);
if( pStyleSheetProperties && pStyleSheetProperties->GetListLevel() >= 0 )
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny(pStyleSheetProperties->GetListLevel()), false);
}
break;
case NS_ooxml::LN_EG_RPrBase_rStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert( PROP_CHAR_STYLE_NAME, true, uno::makeAny( m_pImpl->GetStyleSheetTable()->ConvertStyleName( sStringValue, true )));
break;
case NS_ooxml::LN_CT_TblPrBase_tblCellMar: //cell margins
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);//contains LN_CT_TblCellMar_top, LN_CT_TblCellMar_left, LN_CT_TblCellMar_bottom, LN_CT_TblCellMar_right
}
break;
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
MeasureHandlerPtr pMeasureHandler( new MeasureHandler );
pProperties->resolve(*pMeasureHandler);
sal_Int32 nMeasureValue = pMeasureHandler->getMeasureValue();
PropertyIds eId = META_PROP_CELL_MAR_TOP;
switch(nSprmId)
{
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: */
break;
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_LEFT;
break;
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_BOTTOM;
break;
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_RIGHT;
break;
default:;
}
rContext->Insert( eId, false, uno::makeAny(nMeasureValue), false);
}
}
break;
case NS_sprm::LN_CFNoProof: //0x875 no grammar and spell checking, unsupported
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_anchor_anchor: // at_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_inline_inline: // as_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
GraphicImportType eGraphicType =
(NS_ooxml::LN_anchor_anchor ==
sal::static_int_cast<Id>(nSprmId)) ?
IMPORT_AS_DETECTED_ANCHOR :
IMPORT_AS_DETECTED_INLINE;
GraphicImportPtr pGraphicImport =
m_pImpl->GetGraphicImport(eGraphicType);
pProperties->resolve(*pGraphicImport);
m_pImpl->ImportGraphic(pProperties, eGraphicType);
if( !pGraphicImport->IsGraphic() )
{
m_pImpl->ResetGraphicImport();
// todo: It's a shape, now start shape import
}
}
}
break;
case NS_ooxml::LN_EG_RPrBase_vertAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
if( sStringValue.equalsAscii( "superscript" ))
nEscapement = 101;
else if( sStringValue.equalsAscii( "subscript" ))
nEscapement = -101;
else
nProp = 100;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
// case NS_ooxml::LN_CT_FtnEdn_type
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnEdn_id
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_EG_FtnEdnNumProps_numRestart
case NS_ooxml::LN_CT_FtnProps_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnotes in word can be at page end or beneath text - writer supports only the first
//endnotes in word can be at section end or document end - writer supports only the latter
// -> so this property can be ignored
break;
case NS_ooxml::LN_EG_FtnEdnNumProps_numStart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_FtnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_EdnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
try
{
uno::Reference< beans::XPropertySet > xFtnEdnSettings;
if( m_pImpl->IsInFootnoteProperties() )
{
uno::Reference< text::XFootnotesSupplier> xFootnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xFootnotesSupplier->getFootnoteSettings();
}
else
{
uno::Reference< text::XEndnotesSupplier> xEndnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xEndnotesSupplier->getEndnoteSettings();
}
if( NS_ooxml::LN_EG_FtnEdnNumProps_numStart == nSprmId )
{
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_START_AT),
uno::makeAny( sal_Int16( nIntValue - 1 )));
}
else
{
sal_Int16 nNumType = ConversionHelper::ConvertNumberingType( nIntValue );
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_NUMBERING_TYPE),
uno::makeAny( nNumType ));
}
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_trackchange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
case NS_ooxml::LN_EG_RPrContent_rPrChange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
{
resolveSprmProps( rSprm );
// now the properties author, date and id should be available
::rtl::OUString sAuthor = m_pImpl->GetCurrentRedlineAuthor();
::rtl::OUString sDate = m_pImpl->GetCurrentRedlineDate();
::rtl::OUString sId = m_pImpl->GetCurrentRedlineId();
sal_Int32 nToken = m_pImpl->GetCurrentRedlineToken();
switch( nToken & 0xffff )
{
case ooxml::OOXML_mod :
case ooxml::OOXML_ins :
case ooxml::OOXML_del : break;
default: OSL_ENSURE( false, "redline token other than mod, ins or del" );
}
}
break;
case NS_ooxml::LN_CT_RPrChange_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
break;
/* WRITERFILTERSTATUS: done: 0, planned: 4, spent: 0 */
case NS_ooxml::LN_object:
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
OLEHandlerPtr pOLEHandler( new OLEHandler );
pProperties->resolve(*pOLEHandler);
::rtl::OUString sStreamName = pOLEHandler->copyOLEOStream( m_pImpl->GetTextDocument() );
if(sStreamName.getLength())
{
m_pImpl->appendOLE( sStreamName, pOLEHandler );
}
}
}
break;
// case NS_ooxml::LN_CT_EdnProps_pos
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnProps_numFmt
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnDocProps_footnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnDocProps_endnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//break;
case NS_ooxml::LN_EG_HdrFtrReferences_headerReference: // header reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_HdrFtrReferences_footerReference: // footer reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_EG_RPrBase_snapToGrid: // "Use document grid settings for inter-paragraph spacing"
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_sprm::LN_PContextualSpacing:
//TODO: determines whether top/bottom paragraph spacing is added if equal styles are following - unsupported
break;
case NS_ooxml::LN_EG_SectPrContents_formProt: //section protection, only form editing is enabled - unsupported
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Lvl_pStyle:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//TODO: numbering style should apply current numbering level - not yet supported
break;
default:
{
#if OSL_DEBUG_LEVEL > 0
::rtl::OString sMessage( "DomainMapper::sprm() - Id: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nSprmId ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nSprmId ), 16 );
OSL_ENSURE( false, sMessage.getStr()); //
#endif
}
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("sprm");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::entry(int /*pos*/,
writerfilter::Reference<Properties>::Pointer_t ref)
{
ref->resolve(*this);
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::data(const sal_uInt8* /*buf*/, size_t /*len*/,
writerfilter::Reference<Properties>::Pointer_t /*ref*/)
{
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startSectionGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("section");
#endif
m_pImpl->PushProperties(CONTEXT_SECTION);
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endSectionGroup()
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_SECTION);
SectionPropertyMap* pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->CloseSectionGroup( *m_pImpl );
m_pImpl->PopProperties(CONTEXT_SECTION);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("section");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startParagraphGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("paragraph");
#endif
m_pImpl->getTableManager().startParagraphGroup();
m_pImpl->PushProperties(CONTEXT_PARAGRAPH);
static ::rtl::OUString sDefault( ::rtl::OUString::createFromAscii("Standard") );
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sDefault ) );
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
}
m_pImpl->clearDeferredBreaks();
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endParagraphGroup()
{
//handle unprocessed deferred breaks
PropertyMapPtr pParaProperties = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pParaProperties->hasEmptyPropertyValues() )
{
PropertyMap::const_iterator aIter = pParaProperties->find(PropertyDefinition( PROP_BREAK_TYPE , false ) );
if( aIter != pParaProperties->end() )
{
style::BreakType eType;
aIter->second >>= eType;
bool bPage = false;
bool bColumn = false;
if( eType == style::BreakType_PAGE_BEFORE )
bPage = true;
else if( eType == style::BreakType_COLUMN_BEFORE )
bColumn = true;
if( bPage || bColumn )
{
try
{
uno::Reference< beans::XPropertySet > xRangeProperties( m_pImpl->GetTopTextAppend()->getEnd(), uno::UNO_QUERY_THROW );
xRangeProperties->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_BREAK_TYPE),
uno::makeAny( bPage ? style::BreakType_PAGE_BEFORE : style::BreakType_COLUMN_BEFORE));
}
catch( const uno::Exception& )
{
}
}
}
}
m_pImpl->PopProperties(CONTEXT_PARAGRAPH);
m_pImpl->getTableManager().endParagraphGroup();
//frame conversion has to be executed after table conversion
m_pImpl->ExecuteFrameConversion();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("paragraph");
#endif
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushStyleSheetProperties( PropertyMapPtr pStyleProperties )
{
m_pImpl->PushStyleProperties( pStyleProperties );
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopStyleSheetProperties()
{
m_pImpl->PopProperties( CONTEXT_STYLESHEET );
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushListProperties( ::boost::shared_ptr<PropertyMap> pListProperties )
{
m_pImpl->PushListProperties( pListProperties );
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopListProperties()
{
m_pImpl->PopProperties( CONTEXT_LIST );
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startCharacterGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("charactergroup");
#endif
m_pImpl->PushProperties(CONTEXT_CHARACTER);
DomainMapperTableManager& rTableManager = m_pImpl->getTableManager();
if( rTableManager.getTableStyleName().getLength() )
{
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
rTableManager.CopyTextProperties(pTopContext, m_pImpl->GetStyleSheetTable());
}
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endCharacterGroup()
{
m_pImpl->PopProperties(CONTEXT_CHARACTER);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("charactergroup");
#endif
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::text(const sal_uInt8 * data_, size_t len)
{
//TODO: Determine the right text encoding (FIB?)
::rtl::OUString sText( (const sal_Char*) data_, len, RTL_TEXTENCODING_MS_1252 );
try
{
if(len == 1)
{
switch(*data_)
{
case 0x02: return; //footnote character
case 0x0c: //page break
m_pImpl->deferBreak(PAGE_BREAK);
return;
case 0x0e: //column break
m_pImpl->deferBreak(COLUMN_BREAK);
return;
case 0x07:
m_pImpl->getTableManager().text(data_, len);
case 0x0d:
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
return;
case 0x13:
m_pImpl->PushFieldContext();
return;
case 0x14:
// delimiter not necessarily available
// appears only if field contains further content
m_pImpl->CloseFieldCommand();
return;
case 0x15: /* end of field */
m_pImpl->PopFieldContext();
return;
default:
break;
}
}
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
if( pContext->GetFootnote().is() && m_pImpl->IsCustomFtnMark() )
{
pContext->GetFootnote()->setLabel( sText );
m_pImpl->SetCustomFtnMark( false );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
{
//--> debug
//sal_uInt32 nSize = pContext->size();
//<--
m_pImpl->appendTextPortion( sText, pContext );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("text");
dmapper_logger->chars(sText);
dmapper_logger->endElement("text");
#endif
}
}
catch( const uno::RuntimeException& )
{
std::clog << __FILE__ << "(l" << __LINE__ << ")" << std::endl;
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::utext(const sal_uInt8 * data_, size_t len)
{
OUString sText;
OUStringBuffer aBuffer = OUStringBuffer(len);
aBuffer.append( (const sal_Unicode *) data_, len);
sText = aBuffer.makeStringAndClear();
try
{
m_pImpl->getTableManager().utext(data_, len);
if(len == 1 && ((*data_) == 0x0d || (*data_) == 0x07))
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
else
{
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
/* doesn't seem to be working
if( pContext->GetFootnote().is() )
{
//todo: the check for 0x0a is a hack!
if( *data_ != 0x0a && !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else */
if( pContext && pContext->GetFootnote().is() )
{
if( !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
m_pImpl->appendTextPortion( sText, pContext );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("utext");
dmapper_logger->chars(sText);
dmapper_logger->endElement("utext");
#endif
}
}
catch( const uno::RuntimeException& )
{
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::props(writerfilter::Reference<Properties>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("props");
#endif
string sType = ref->getType();
if( sType == "PICF" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_GRAPHIC);
}
else if( sType == "FSPA" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_SHAPE);
}
else
ref->resolve(*this);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("props");
#endif
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("table");
dmapper_logger->attribute("id", (*QNameToString::Instance())(name));
#endif
// printf ( "DomainMapper::table(0x%.4x)\n", (unsigned int)name);
m_pImpl->SetAnyTableImport(true);
/* WRITERFILTERSTATUS: table: attributedata */
switch(name)
{
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// create a font table object that listens to the attributes
// each entry call inserts a new font entry
ref->resolve( *m_pImpl->GetFontTable() );
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//same as above to import style sheets
m_pImpl->SetStyleSheetImport( true );
ref->resolve( *m_pImpl->GetStyleSheetTable() );
m_pImpl->GetStyleSheetTable()->ApplyStyleSheets(m_pImpl->GetFontTable());
m_pImpl->SetStyleSheetImport( false );
break;
case NS_ooxml::LN_NUMBERING:
case NS_rtf::LN_LISTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//the same for list tables
ref->resolve( *m_pImpl->GetListTable() );
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
ref->resolve( *m_pImpl->GetLFOTable() );
break;
case NS_ooxml::LN_THEMETABLE:
ref->resolve ( *m_pImpl->GetThemeTable() );
break;
case NS_ooxml::LN_settings_settings:
ref->resolve ( *m_pImpl->GetSettingsTable() );
m_pImpl->ApplySettingsTable();
break;
default:
OSL_ENSURE( false, "which table is to be filled here?");
}
m_pImpl->SetAnyTableImport(false);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("table");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::substream(Id rName, ::writerfilter::Reference<Stream>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("substream");
#endif
m_pImpl->getTableManager().startLevel();
//->debug
//string sName = (*QNameToString::Instance())(rName);
//--<debug
//import of page header/footer
/* WRITERFILTERSTATUS: table: attributedata */
switch( rName )
{
case NS_rtf::LN_headerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_headerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_footerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PushFootOrEndnote( NS_rtf::LN_footnote == rName );
break;
case NS_rtf::LN_annotation :
m_pImpl->PushAnnotation();
break;
}
ref->resolve(*this);
switch( rName )
{
case NS_rtf::LN_headerl:
case NS_rtf::LN_headerr:
case NS_rtf::LN_headerf:
case NS_rtf::LN_footerl:
case NS_rtf::LN_footerr:
case NS_rtf::LN_footerf:
m_pImpl->PopPageHeaderFooter();
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PopFootOrEndnote();
break;
case NS_rtf::LN_annotation :
m_pImpl->PopAnnotation();
break;
}
m_pImpl->getTableManager().endLevel();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("substream");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::info(const string & /*info_*/)
{
}
void DomainMapper::handleUnderlineType(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext)
{
sal_Int16 eUnderline = awt::FontUnderline::NONE;
switch(nIntValue)
{
case 0: eUnderline = awt::FontUnderline::NONE; break;
case 2: pContext->Insert(PROP_CHAR_WORD_MODE, true, uno::makeAny( true ) ); // TODO: how to get rid of it?
case 1: eUnderline = awt::FontUnderline::SINGLE; break;
case 3: eUnderline = awt::FontUnderline::DOUBLE; break;
case 4: eUnderline = awt::FontUnderline::DOTTED; break;
case 7: eUnderline = awt::FontUnderline::DASH; break;
case 9: eUnderline = awt::FontUnderline::DASHDOT; break;
case 10:eUnderline = awt::FontUnderline::DASHDOTDOT; break;
case 6: eUnderline = awt::FontUnderline::BOLD; break;
case 11:eUnderline = awt::FontUnderline::WAVE; break;
case 20:eUnderline = awt::FontUnderline::BOLDDOTTED; break;
case 23:eUnderline = awt::FontUnderline::BOLDDASH; break;
case 39:eUnderline = awt::FontUnderline::LONGDASH; break;
case 55:eUnderline = awt::FontUnderline::BOLDLONGDASH; break;
case 25:eUnderline = awt::FontUnderline::BOLDDASHDOT; break;
case 26:eUnderline = awt::FontUnderline::BOLDDASHDOTDOT;break;
case 27:eUnderline = awt::FontUnderline::BOLDWAVE; break;
case 43:eUnderline = awt::FontUnderline::DOUBLEWAVE; break;
default: ;
}
pContext->Insert(PROP_CHAR_UNDERLINE, true, uno::makeAny( eUnderline ) );
}
void DomainMapper::handleParaJustification(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext, const bool bExchangeLeftRight)
{
sal_Int16 nAdjust = 0;
sal_Int16 nLastLineAdjust = 0;
switch(nIntValue)
{
case 1:
nAdjust = style::ParagraphAdjust_CENTER;
break;
case 2:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_LEFT : style::ParagraphAdjust_RIGHT);
break;
case 4:
nLastLineAdjust = style::ParagraphAdjust_BLOCK;
//no break;
case 3:
nAdjust = style::ParagraphAdjust_BLOCK;
break;
case 0:
default:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_RIGHT : style::ParagraphAdjust_LEFT);
break;
}
pContext->Insert( PROP_PARA_ADJUST, true, uno::makeAny( nAdjust ) );
pContext->Insert( PROP_PARA_LAST_LINE_ADJUST, true, uno::makeAny( nLastLineAdjust ) );
}
bool DomainMapper::getColorFromIndex(const sal_Int32 nIndex, sal_Int32 &nColor)
{
nColor = 0;
if ((nIndex < 1) || (nIndex > 16))
return false;
switch (nIndex)
{
case 1: nColor=0x000000; break; //black
case 2: nColor=0x0000ff; break; //blue
case 3: nColor=0x00ffff; break; //cyan
case 4: nColor=0x00ff00; break; //green
case 5: nColor=0xff00ff; break; //magenta
case 6: nColor=0xff0000; break; //red
case 7: nColor=0xffff00; break; //yellow
case 8: nColor=0xffffff; break; //white
case 9: nColor=0x000080; break;//dark blue
case 10: nColor=0x008080; break; //dark cyan
case 11: nColor=0x008000; break; //dark green
case 12: nColor=0x800080; break; //dark magenta
case 13: nColor=0x800000; break; //dark red
case 14: nColor=0x808000; break; //dark yellow
case 15: nColor=0x808080; break; //dark gray
case 16: nColor=0xC0C0C0; break; //light gray
default:
return false;
}
return true;
}
sal_Int16 DomainMapper::getEmphasisValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1:
return com::sun::star::text::FontEmphasis::DOT_ABOVE;
case 2:
return com::sun::star::text::FontEmphasis::ACCENT_ABOVE;
case 3:
return com::sun::star::text::FontEmphasis::CIRCLE_ABOVE;
case 4:
return com::sun::star::text::FontEmphasis::DOT_BELOW;
default:
return com::sun::star::text::FontEmphasis::NONE;
}
}
rtl::OUString DomainMapper::getBracketStringFromEnum(const sal_Int32 nIntValue, const bool bIsPrefix)
{
switch(nIntValue)
{
case 1:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "(" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ")" ));
case 2:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "[" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "]" ));
case 3:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "<" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ">" ));
case 4:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "{" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "}" ));
case 0:
default:
return rtl::OUString();
}
}
void DomainMapper::resolveSprmProps(Sprm & rSprm)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
pProperties->resolve(*this);
}
void DomainMapper::resolveAttributeProperties(Value & val)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
pProperties->resolve(*this);
}
com::sun::star::style::TabAlign DomainMapper::getTabAlignFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 0:
case 4: // bar not supported
return com::sun::star::style::TabAlign_LEFT;
case 1:
return com::sun::star::style::TabAlign_CENTER;
case 2:
return com::sun::star::style::TabAlign_RIGHT;
case 3:
return com::sun::star::style::TabAlign_DECIMAL;
default:
return com::sun::star::style::TabAlign_DEFAULT;
}
return com::sun::star::style::TabAlign_LEFT;
}
sal_Unicode DomainMapper::getFillCharFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1: // dot
return sal_Unicode(0x002e);
case 2: // hyphen
return sal_Unicode(0x002d);
case 3: // underscore
case 4: // heavy FIXME ???
return sal_Unicode(0x005f);
case NS_ooxml::LN_Value_ST_TabTlc_middleDot: // middleDot
return sal_Unicode(0x00b7);
case 0: // none
default:
return sal_Unicode(0x0020); // blank space
}
}
/*-- 18.07.2007 14:59:00---------------------------------------------------
-----------------------------------------------------------------------*/
bool DomainMapper::IsOOXMLImport() const
{
return m_pImpl->IsOOXMLImport();
}
/*-- 18.07.2007 16:03:14---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference < lang::XMultiServiceFactory > DomainMapper::GetTextFactory() const
{
return m_pImpl->GetTextFactory();
}
/*-- 12.11.2007 10:41:01---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::AddListIDToLFOTable( sal_Int32 nAbstractNumId )
{
m_pImpl->GetLFOTable()->AddListID( nAbstractNumId );
}
/*-- 31.01.2008 18:19:44---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference< text::XTextRange > DomainMapper::GetCurrentTextRange()
{
return m_pImpl->GetTopTextAppend()->getEnd();
}
/*-- 05.02.2008 10:26:26---------------------------------------------------
-----------------------------------------------------------------------*/
::rtl::OUString DomainMapper::getOrCreateCharStyle( PropertyValueVector_t& rCharProperties )
{
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
return pStyleSheets->getOrCreateCharStyle( rCharProperties );
}
} //namespace dmapper
} //namespace writerfilter
Reflect renamings in doctok/resources.xmi
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: DomainMapper.cxx,v $
*
* $Revision: 1.69 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include <dmapper/DomainMapper.hxx>
#include <DomainMapper_Impl.hxx>
#include <ConversionHelper.hxx>
#include <ThemeTable.hxx>
#include <ModelEventListener.hxx>
#include <MeasureHandler.hxx>
#include <OLEHandler.hxx>
#include <i18npool/mslangid.hxx>
#include <i18npool/paper.hxx>
#include <ooxml/OOXMLFastTokens.hxx>
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#include <com/sun/star/document/XOOXMLDocumentPropertiesImporter.hpp>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/RelOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/WrapTextMode.hpp>
#include <com/sun/star/text/SizeType.hpp>
#include <com/sun/star/text/XEndnotesSupplier.hpp>
#include <com/sun/star/text/XFootnotesSupplier.hpp>
#include <com/sun/star/text/XLineNumberingProperties.hpp>
#include <com/sun/star/text/XTextDocument.hpp>
#include <com/sun/star/text/XTextCursor.hpp>
#include <com/sun/star/text/XTextPortionAppend.hpp>
#include <com/sun/star/text/XParagraphAppend.hpp>
#include <com/sun/star/text/FontEmphasis.hpp>
#include <com/sun/star/awt/FontRelief.hpp>
#include <com/sun/star/awt/FontWeight.hpp>
#include <com/sun/star/awt/FontUnderline.hpp>
#include <com/sun/star/awt/FontStrikeout.hpp>
#include <com/sun/star/awt/FontSlant.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/document/XEventBroadcaster.hpp>
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/style/BreakType.hpp>
#include <com/sun/star/style/CaseMap.hpp>
#include <com/sun/star/style/LineSpacing.hpp>
#include <com/sun/star/style/LineSpacingMode.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <com/sun/star/text/TextGridMode.hpp>
#include <com/sun/star/text/XDocumentIndexesSupplier.hpp>
#include <com/sun/star/text/WritingMode.hpp>
#include <com/sun/star/text/XFootnote.hpp>
#include <com/sun/star/style/NumberingType.hpp>
#include <comphelper/types.hxx>
#include <comphelper/storagehelper.hxx>
#include <rtl/ustrbuf.hxx>
#include <boost/shared_ptr.hpp>
#include <com/sun/star/uno/Any.hxx>
#include <tools/color.hxx>
#include <BorderHandler.hxx>
#include <CellColorHandler.hxx>
#include <SectionColumnHandler.hxx>
#include <vector>
#include <iostream>
#ifdef DEBUG_DOMAINMAPPER
#include <resourcemodel/QNameToString.hxx>
#include <resourcemodel/util.hxx>
#include <resourcemodel/TagLogger.hxx>
#endif
#if OSL_DEBUG_LEVEL > 0
#include <resourcemodel/QNameToString.hxx>
#endif
using namespace ::com::sun::star;
using namespace ::rtl;
namespace writerfilter {
namespace dmapper{
#ifdef DEBUG_DOMAINMAPPER
TagLogger::Pointer_t dmapper_logger(TagLogger::getInstance("DOMAINMAPPER"));
#endif
/* ---- Fridrich's mess begins here ---- */
struct _PageSz
{
sal_Int32 code;
sal_Int32 h;
bool orient;
sal_Int32 w;
} CT_PageSz;
/* ---- Fridrich's mess (hopefully) ends here ---- */
/*-- 09.06.2006 09:52:11---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::DomainMapper( const uno::Reference< uno::XComponentContext >& xContext,
uno::Reference< io::XInputStream > xInputStream,
uno::Reference< lang::XComponent > xModel,
SourceDocumentType eDocumentType) :
m_pImpl( new DomainMapper_Impl( *this, xContext, xModel, eDocumentType )),
mnBackgroundColor(0), mbIsHighlightSet(false)
{
// #i24363# tab stops relative to indent
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_TABS_RELATIVE_TO_INDENT ),
uno::makeAny( false ) );
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_PARA_TABLE_SPACING ),
uno::makeAny( false ) );
//import document properties
try
{
uno::Reference< lang::XMultiServiceFactory > xFactory(xContext->getServiceManager(), uno::UNO_QUERY_THROW);
uno::Reference< embed::XStorage > xDocumentStorage =
(comphelper::OStorageHelper::GetStorageOfFormatFromInputStream(OFOPXML_STORAGE_FORMAT_STRING, xInputStream));
uno::Reference< uno::XInterface > xTemp = xContext->getServiceManager()->createInstanceWithContext(
::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.OOXMLDocumentPropertiesImporter")),
xContext);
uno::Reference< document::XOOXMLDocumentPropertiesImporter > xImporter( xTemp, uno::UNO_QUERY_THROW );
uno::Reference< document::XDocumentPropertiesSupplier > xPropSupplier( xModel, uno::UNO_QUERY_THROW);
xImporter->importProperties( xDocumentStorage, xPropSupplier->getDocumentProperties() );
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("domainmapper");
#endif
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::~DomainMapper()
{
try
{
uno::Reference< text::XDocumentIndexesSupplier> xIndexesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
uno::Reference< container::XIndexAccess > xIndexes = xIndexesSupplier->getDocumentIndexes();
sal_Int32 nIndexes = xIndexes->getCount();
if( nIndexes )
{
//index update has to wait until first view is created
uno::Reference< document::XEventBroadcaster > xBroadcaster(xIndexesSupplier, uno::UNO_QUERY);
xBroadcaster->addEventListener(uno::Reference< document::XEventListener >(new ModelEventListener));
}
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
delete m_pImpl;
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("domainmapper");
#endif
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::attribute(Id nName, Value & val)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("attribute");
dmapper_logger->attribute("name", (*QNameToString::Instance())(nName));
dmapper_logger->attribute("value", val.toString());
#endif
static ::rtl::OUString sLocalBookmarkName;
sal_Int32 nIntValue = val.getInt();
rtl::OUString sStringValue = val.getString();
// printf ( "DomainMapper::attribute(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nName, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
if( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR )
m_pImpl->GetFIB().SetData( nName, nIntValue );
else //if( !m_pImpl->getTableManager().attribute( nName, val) )
{
/* WRITERFILTERSTATUS: table: attributedata */
switch( nName )
{
/* attributes to be ignored */
case NS_rtf::LN_UNUSED4:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED8:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED1_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED1_7:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED8_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWRITERESERVATION:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FFAREAST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRYPTO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_NFIBBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LKEY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_ENVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWORD97SAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTECHP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTEPAP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTELVC_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CBMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CCPMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWLOWDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWHIGHDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_rtf::LN_ISTD: //index of applied style
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//search for the style with the given id and apply it
//as CharStyleName or ParaStyleName
//if the style is a user defined style then it must have an ISTD - built-in styles might not have it
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
::rtl::OUString sValue = ::rtl::OUString::valueOf(nIntValue, 16);
const StyleSheetEntry* pEntry = pStyleSheets->FindStyleSheetByISTD(sValue);
if(pEntry)
{
bool bParaStyle = (pEntry->nStyleTypeCode == STYLE_TYPE_PARA);
if(bParaStyle)
m_pImpl->SetCurrentParaStyleId(::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16));
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert(
bParaStyle ?
PROP_PARA_STYLE_NAME : PROP_CHAR_STYLE_NAME,
true,
uno::makeAny(
m_pImpl->GetStyleSheetTable()->ConvertStyleName( pEntry->sStyleName ) ) );
}
}
break;
case NS_rtf::LN_ISTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NFC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FLEGAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FNORESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPREV:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPREVSPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FWORD6:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED5_7:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGBXCHNUMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IXCHFOLLOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXASPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAINDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLCHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LSID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_TPLC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGISTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSIMPLELIST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FRESTARTHDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNSIGNED26_2:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ILVL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFORMATTING:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNSIGNED4_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CLFOLVL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBFFNM1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PRQ:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FTRUETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WWEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CHS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetLNCHS( nIntValue );
}
break;
case NS_rtf::LN_IXCHSZALT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PANOSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STI:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSCRATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FINVALHEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHASUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMASSCOPY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SGC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDBASE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CUPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BCHUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FAUTOREDEF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHIDDEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CSTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBSTDBASEINFILE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTDSTYLENAMESWRITTEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED4_2:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STIMAXWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDMAXFIXEDWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NVERBUILTINNAMESWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGFTCSTANDARDCHPSTSH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WIDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NFIB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NPRODUCT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FDOT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCOMPLEX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FHASPIC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CQUICKSAVES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FENCRYPTED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FWHICHTBLSTM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FREADONLYRECOMMENDED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEXTCHAR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEMPTYSPECIAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDEPAGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FFUTURESAVEDUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FSPARE0:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CHSTABLES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CSW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LIDFE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CLW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTECHP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTEPAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CFCLCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetData( nName, nIntValue );
}
break;
case NS_rtf::LN_FN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSEPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FNMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//section descriptor, unused or internally used
break;
case NS_rtf::LN_ICOFORE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICOBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IPAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDFORECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDBACKCOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDPATTERN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTLINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTSPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSHADOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED2_15:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFIRSTMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBACKWARD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FROTATEFONT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTMERGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTRESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_VERTALIGN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
(void)nLineDistance;
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nName )
{
case NS_rtf::LN_BRCTOP:
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCLEFT:
// eBorderId = PROP_LEFT_BORDER;
// eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_rtf::LN_BRCBOTTOM:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCRIGHT:
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
default:;
}
//todo: where to put the border properties
//rContext->Insert(eBorderId, uno::makeAny( aBorderLine ));
//rContext->Insert(eBorderDistId, uno::makeAny( nLineDistance ));
}
break;
case NS_rtf::LN_ITCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPUB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ITCLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FCOL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_YEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_HMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBHEADER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MFP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BM_RCWINMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAMEEMPTY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBITMAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FDRAWHATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FERROR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BPP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CPROPS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSHORIZONTAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_endnote:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BOOKMARKNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// sStringValue contains the bookmark name
sLocalBookmarkName = sStringValue;
break;
case NS_rtf::LN_IBKL:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0.5 */
//contains the bookmark identifier - has to be added to the bookmark name imported before
//if it is already available then the bookmark should be inserted
m_pImpl->AddBookmark( sLocalBookmarkName, sStringValue );
sLocalBookmarkName = ::rtl::OUString();
break;
case NS_rtf::LN_LISTLEVEL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_F:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ALTFONTNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSZFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPXSTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_sed:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//section properties
resolveAttributeProperties(val);
break;
case NS_rtf::LN_tbdAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
{
pProperties->resolve(*this);
//increment to the next tab stop
m_pImpl->NextTabStop();
}
}
break;
case NS_rtf::LN_dxaDel:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//deleted tab
case NS_rtf::LN_dxaAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//set tab
case NS_rtf::LN_TLC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab leading characters - for decimal tabs
case NS_rtf::LN_JC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab justification
m_pImpl->ModifyCurrentTabStop(nName, nIntValue);
break;
case NS_rtf::LN_UNUSED0_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// really unused
break;
case NS_rtf::LN_rgbrc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_shd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellShd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellTopColor:
case NS_rtf::LN_cellLeftColor:
case NS_rtf::LN_cellBottomColor:
case NS_rtf::LN_cellRightColor:
OSL_ASSERT("handled by DomainMapperTableManager");
break;
case NS_rtf::LN_LISTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fcEastAsianLayout:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
/* it seems that the value is following:
???? XX YYYY ZZ
where
XX seems to be the run id
ZZ is the length of the function that is normally 6
Lower byte of YYYY determines whether it is
vertical text flow (0x01), or
two lines in one layout (0x02).
For 0x01, if the higher byte of YYYY is zero, the text is not scaled to fit the line height,
in oposite case, it is to be scaled.
For 0x02, the higher byte of YYYY is determinig the prefix and suffix of the run:
no brackets (0x00) ,
() round brackets (0x01),
[] square backets (0x02),
<> angle brackets (0x03) and
{} curly brackets (0x04).
???? is different and we do not know its signification
*/
if ((nIntValue & 0x000000FF) == 6)
{
switch ((nIntValue & 0x0000FF00) >> 8)
{
case 1: // vertical text
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( sal_Int16(900) ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny (((nIntValue & 0x00FF0000) >> 16) != 0));
}
break;
case 2: // two lines in one
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( true ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16)));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16, false)));
}
break;
default:
break;
}
}
break;
case NS_rtf::LN_FRD :
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnote reference descriptor, if nIntValue > 0 then automatic, custom otherwise
//ignored
break;
case NS_rtf::LN_FONT: //font of footnote symbol
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteFontId( nIntValue );
break;
case NS_ooxml::LN_CT_Sym_char:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
m_pImpl->GetTopContext()->GetFootnote()->setLabel(::rtl::OUString( sal_Unicode(nIntValue)));
break;
}
else //it's a _real_ symbol
{
utext( reinterpret_cast < const sal_uInt8 * >( &nIntValue ), 1 );
}
break;
case NS_rtf::LN_CHAR: //footnote symbol character
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteSymbol( sal_Unicode(nIntValue));
break;
case NS_ooxml::LN_CT_Sym_font:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//the footnote symbol and font are provided after the footnote is already inserted
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
uno::Reference< beans::XPropertySet > xAnchorProps( m_pImpl->GetTopContext()->GetFootnote()->getAnchor(), uno::UNO_QUERY );
xAnchorProps->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_CHAR_FONT_NAME),
uno::makeAny( sStringValue ));
}
else //a real symbol
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Underline_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
handleUnderlineType(nIntValue, m_pImpl->GetTopContext());
break;
case NS_ooxml::LN_CT_Color_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nIntValue ) );
break;
case NS_ooxml::LN_CT_Underline_color:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nIntValue ) );
}
break;
case NS_ooxml::LN_CT_TabStop_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_ST_TabJc_clear)
m_pImpl->m_aCurrentTabStop.bDeleted = true;
else
{
m_pImpl->m_aCurrentTabStop.bDeleted = false;
m_pImpl->m_aCurrentTabStop.Alignment = getTabAlignFromValue(nIntValue);
}
break;
case NS_ooxml::LN_CT_TabStop_leader:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.FillChar = getFillCharFromValue(nIntValue);
break;
case NS_ooxml::LN_CT_TabStop_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.Position = ConversionHelper::convertTwipToMM100(nIntValue);
break;
case NS_ooxml::LN_CT_Fonts_ascii:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_asciiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Fonts_hAnsi:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;//unsupported
case NS_ooxml::LN_CT_Fonts_hAnsiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break; //unsupported
case NS_ooxml::LN_CT_Fonts_eastAsia:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_ASIAN, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_eastAsiaTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ) );
break;
case NS_ooxml::LN_CT_Fonts_cs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_cstheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Spacing_before:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_beforeLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_after:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_afterLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_line: //91434
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Spacing_lineRule: //91435
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
#define SINGLE_LINE_SPACING 240
style::LineSpacing aSpacing;
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
PropertyMap::iterator aLineSpacingIter = pTopContext->find(PropertyDefinition( PROP_PARA_LINE_SPACING, true ) );
if( aLineSpacingIter != pTopContext->end())
{
aLineSpacingIter->second >>= aSpacing;
}
else
{
//default to single line spacing
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
if( nName == NS_ooxml::LN_CT_Spacing_line )
{
//now set the value depending on the Mode
if( aSpacing.Mode == style::LineSpacingMode::PROP )
aSpacing.Height = sal_Int16(sal_Int32(nIntValue) * 100 / SINGLE_LINE_SPACING );
else
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( nIntValue ));
}
else //NS_ooxml::LN_CT_Spacing_lineRule:
{
// exactly, atLeast, auto
if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_auto)
{
aSpacing.Mode = style::LineSpacingMode::PROP;
//reinterpret the already set value
aSpacing.Height = sal_Int16( aSpacing.Height * 100 / ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
else if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_atLeast)
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
else // NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_exact
aSpacing.Mode = style::LineSpacingMode::FIX;
}
pTopContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case NS_ooxml::LN_CT_Ind_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_LEFT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_RIGHT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_hanging:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( - ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_firstLine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_EastAsianLayout_combine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( nIntValue ? true : false ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_combineBrackets:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
rtl::OUString sCombinePrefix = getBracketStringFromEnum(nIntValue);
rtl::OUString sCombineSuffix = getBracketStringFromEnum(nIntValue, false);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( sCombinePrefix ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( sCombineSuffix ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vert:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
sal_Int16 nRotationAngle = (nIntValue ? 900 : 0);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( nRotationAngle ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vertCompress:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny ( nIntValue ? true : false));
break;
case NS_ooxml::LN_CT_PageSz_code:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = nIntValue;
break;
case NS_ooxml::LN_CT_PageSz_h:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.h = PaperInfo::sloppyFitPageDimension(nHeight);
}
break;
case NS_ooxml::LN_CT_PageSz_orient:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.orient = (nIntValue != 0);
break;
case NS_ooxml::LN_CT_PageSz_w:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.w = PaperInfo::sloppyFitPageDimension(nWidth);
}
break;
case NS_ooxml::LN_CT_PageMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_TOP, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_RIGHT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_BOTTOM, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_LEFT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_header:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_HEADER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_footer:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_FOOTER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_gutter:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_GUTTER, nIntValue );
break;
case NS_ooxml::LN_CT_Language_val: //90314
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_eastAsia: //90315
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_bidi: //90316
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
LanguageType eLang = MsLangId::convertIsoStringToLanguage( sStringValue );
lang::Locale aLocale = MsLangId::convertLanguageToLocale( eLang );
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(NS_ooxml::LN_CT_Language_val== nName ? PROP_CHAR_LOCALE :
NS_ooxml::LN_CT_Language_eastAsia == nName ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
#define AUTO_PARA_SPACING sal_Int32(49)
case NS_ooxml::LN_CT_Spacing_beforeAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
//and should be set to 0 on start of page
m_pImpl->GetTopContext()->Insert( PROP_TOP_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_Spacing_afterAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
m_pImpl->GetTopContext()->Insert( PROP_BOTTOM_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_SmartTagRun_uri:
case NS_ooxml::LN_CT_SmartTagRun_element:
/* WRITERFILTERSTATUS: done: 0, planned: 1, spent: 0 */
//TODO: add handling of SmartTags
break;
case NS_ooxml::LN_CT_Br_type :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//TODO: attributes for break (0x12) are not supported
break;
case NS_ooxml::LN_CT_Fonts_hint :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
/* assigns script type to ambigous characters, values can be:
NS_ooxml::LN_Value_ST_Hint_default
NS_ooxml::LN_Value_ST_Hint_eastAsia
NS_ooxml::LN_Value_ST_Hint_cs
*/
//TODO: unsupported?
break;
case NS_ooxml::LN_CT_TblCellMar_right: // 92375;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_top: // 92377;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_left: // 92378;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_bottom: // 92379;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//todo: handle cell mar
break;
case NS_rtf::LN_blip: // contains the binary graphic
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_shape:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
{
//looks a bit like a hack - and it is. The graphic import is split into the inline_inline part and
//afterwards the adding of the binary data.
m_pImpl->GetGraphicImport( IMPORT_AS_DETECTED_INLINE )->attribute(nName, val);
m_pImpl->ImportGraphic( val.getProperties(), IMPORT_AS_DETECTED_INLINE );
if( m_pImpl->IsInShapeContext() )
{
//imported text from temporary shape needs to be copied to the real shape
uno::Reference< drawing::XShape > xShape;
val.getAny() >>= xShape;
m_pImpl->CopyTemporaryShapeText( xShape );
}
}
break;
case NS_ooxml::LN_CT_FramePr_dropCap:
case NS_ooxml::LN_CT_FramePr_lines:
case NS_ooxml::LN_CT_FramePr_hAnchor:
case NS_ooxml::LN_CT_FramePr_vAnchor:
case NS_ooxml::LN_CT_FramePr_x:
case NS_ooxml::LN_CT_FramePr_xAlign:
case NS_ooxml::LN_CT_FramePr_y:
case NS_ooxml::LN_CT_FramePr_yAlign:
case NS_ooxml::LN_CT_FramePr_hRule:
case NS_sprm::LN_PWr:
case NS_sprm::LN_PDxaWidth:
case NS_sprm::LN_PWHeightAbs:
case NS_sprm::LN_PDxaFromText:
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
ParagraphProperties* pParaProperties = dynamic_cast< ParagraphProperties*>(m_pImpl->GetTopContext().get());
if( pParaProperties )
{
switch( nName )
{
case NS_ooxml::LN_CT_FramePr_dropCap:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetDropCap( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_lines:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetLines( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_text: //relative to column
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_margin: nIntValue = text::RelOrientation::PAGE_PRINT_AREA; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SethAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_vAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_text: //relative to paragraph
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_margin:nIntValue = text::RelOrientation::PAGE_PRINT_AREA ; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SetvAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_x:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setx( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_xAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_center : nIntValue = text::HoriOrientation::CENTER; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_right : nIntValue = text::HoriOrientation::RIGHT; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_inside : nIntValue = text::HoriOrientation::INSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_outside : nIntValue = text::HoriOrientation::OUTSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_left : nIntValue = text::HoriOrientation::LEFT; break;
default: nIntValue = text::HoriOrientation::NONE;
}
pParaProperties->SetxAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_y:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Sety( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_yAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_top :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inside :nIntValue = text::VertOrientation::TOP; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_center :nIntValue = text::VertOrientation::CENTER;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_bottom :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_outside :nIntValue = text::VertOrientation::BOTTOM;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inline ://todo: what to do with inline - no avail. in WW97 and WW2007
//no break;
default:nIntValue = text::VertOrientation::NONE;
}
pParaProperties->SetyAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hRule:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_exact:
nIntValue = text::SizeType::FIX;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_atLeast:
nIntValue = text::SizeType::MIN;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_auto:
//no break;
default:;
nIntValue = text::SizeType::VARIABLE;
}
pParaProperties->SethRule( nIntValue );
break;
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//should be either LN_Value_wordprocessingml_ST_Wrap_notBeside or LN_Value_wordprocessingml_ST_Wrap_around
OSL_ENSURE( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ||
sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_notBeside,
"wrap not around or not_Beside?");
pParaProperties->SetWrap(sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ?
text::WrapTextMode_DYNAMIC : text::WrapTextMode_NONE );
}
break;
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setw(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Seth(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SethSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetvSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
default:;
}
}
else
{
//TODO: how to handle frame properties at styles
}
}
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TrackChange_author:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineAuthor( sStringValue );
break;
case NS_ooxml::LN_CT_TrackChange_date:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineDate( sStringValue );
break;
case NS_ooxml::LN_CT_Markup_id:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineId( sStringValue );
break;
case NS_ooxml::LN_token:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineToken( nIntValue );
break;
case NS_ooxml::LN_mark_shape:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if( nIntValue )
m_pImpl->PopShapeContext();
else
m_pImpl->PushShapeContext();
break;
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
//line numbering in Writer is a global document setting
//in Word is a section setting
//if line numbering is switched on anywhere in the document it's set at the global settings
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
switch( nName )
{
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nInterval = nIntValue;
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nStartValue = nIntValue; // todo: has to be set at (each) first paragraph
break;
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nDistance = ConversionHelper::convertTwipToMM100( nIntValue );
break;
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page:empty, probably 0,section:1,continuous:2;
aSettings.bRestartAtEachPage = nIntValue < 1;
break;
default:;
}
m_pImpl->SetLineNumberSettings( aSettings );
}
break;
case NS_ooxml::LN_CT_FtnEdnRef_customMarkFollows:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCustomFtnMark( true );
break;
case NS_ooxml::LN_CT_FtnEdnRef_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// footnote or endnote reference id - not needed
case NS_ooxml::LN_CT_Color_themeColor:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeTint:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeShade:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//unsupported
break;
default:
{
#if OSL_DEBUG_LEVEL > 0
::rtl::OString sMessage( "DomainMapper::attribute() - Id: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 16 );
// sMessage += ::rtl::OString(" / ");
// sMessage += ::rtl::OString
// ((*QNameToString::Instance())(nName).c_str());
sMessage += ::rtl::OString(" value: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 16 );
OSL_ENSURE( false, sMessage.getStr()); //
#endif
}
}
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("attribute");
#endif
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm(Sprm & rSprm)
{
if( !m_pImpl->getTableManager().sprm(rSprm))
DomainMapper::sprm( rSprm, m_pImpl->GetTopContext() );
}
/*-- 20.06.2006 09:58:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm( Sprm& rSprm, PropertyMapPtr rContext, SprmType eSprmType )
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("sprm");
dmapper_logger->chars(rSprm.toString());
#endif
OSL_ENSURE(rContext.get(), "PropertyMap has to be valid!");
if(!rContext.get())
return ;
sal_uInt32 nSprmId = rSprm.getId();
//needed for page properties
SectionPropertyMap* pSectionContext = 0;
//the section context is not availabe before the first call of startSectionGroup()
if( !m_pImpl->IsAnyTableImport() )
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_SECTION);
OSL_ENSURE(pContext.get(), "Section context is not in the stack!");
pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() );
}
//TODO: In rtl-paragraphs the meaning of left/right are to be exchanged
bool bExchangeLeftRight = false;
// if( nSprmId == NS_sprm::LN_PJcExtra && AlreadyInRTLPara() )
// bExchangeLeftRight = true;
Value::Pointer_t pValue = rSprm.getValue();
sal_Int32 nIntValue = pValue->getInt();
rtl::OUString sStringValue = pValue->getString();
// printf ( "DomainMapper::sprm(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nSprmId, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
/* WRITERFILTERSTATUS: table: sprmdata */
switch(nSprmId)
{
case 2: // sprmPIstd
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
case 0x4600:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstd - style code
case 3: // "sprmPIstdPermute
case NS_sprm::LN_PIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstdPermute
case NS_sprm::LN_PIncLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIncLvl
case NS_sprm::LN_PJcExtra: // sprmPJc Asian (undocumented)
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PJc: // sprmPJc
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
handleParaJustification(nIntValue, rContext, bExchangeLeftRight);
break;
case NS_sprm::LN_PFSideBySide:
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
break; // sprmPFSideBySide
case NS_sprm::LN_PFKeep: // sprmPFKeep
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
break;
case NS_sprm::LN_PFKeepFollow: // sprmPFKeepFollow
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_KEEP_TOGETHER, true, uno::makeAny( nIntValue ? true : false) );
break;
case NS_sprm::LN_PFPageBreakBefore:
/* WRITERFILTERSTATUS: done: 100, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE ) );
break; // sprmPFPageBreakBefore
case NS_sprm::LN_PBrcl:
break; // sprmPBrcl
case NS_sprm::LN_PBrcp:
break; // sprmPBrcp
case NS_sprm::LN_PIlvl: // sprmPIlvl
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
//todo: Numbering level will be implemented in the near future (OOo 3.0?)
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListLevel( (sal_Int16)nIntValue );
}
else
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny( (sal_Int16)nIntValue ));
break;
case NS_sprm::LN_PIlfo: // sprmPIlfo
/* WRITERFILTERSTATUS: done: 50, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
{
//convert the ListTable entry to a NumberingRules propery and apply it
sal_Int32 nListId = m_pImpl->GetLFOTable()->GetListID( nIntValue );
if(nListId >= 0)
{
ListTablePtr pListTable = m_pImpl->GetListTable();
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListId( nListId );
}
else
rContext->Insert( PROP_NUMBERING_RULES, true,
uno::makeAny(pListTable->GetNumberingRules(nListId)));
//TODO: Merge overwrittern numbering levels from LFO table
}
}
break;
case NS_sprm::LN_PFNoLineNumb: // sprmPFNoLineNumb
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_LINE_NUMBER_COUNT, true, uno::makeAny( nIntValue ? false : true) );
break;
case NS_sprm::LN_PChgTabsPapx: // sprmPChgTabsPapx
/* WRITERFILTERSTATUS: done: 90, planned: 8, spent: 8 */
/* WRITERFILTERSTATUS: comment: bar tab stops a unavailable */
{
// Initialize tab stop vector from style sheet
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
//create a new tab stop property - this is done with the contained properties
resolveSprmProps(rSprm);
//add this property
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case 0x845d: //right margin Asian - undocumented
case 0x845e: //left margin Asian - undocumented
case 16: // sprmPDxaRight - right margin
case NS_sprm::LN_PDxaRight: // sprmPDxaRight - right margin
case 17:
case NS_sprm::LN_PDxaLeft: // sprmPDxaLeft
/* WRITERFILTERSTATUS: done: 50, planned: 5, spent: 1 */
if( NS_sprm::LN_PDxaLeft == nSprmId || 0x17 == nSprmId|| (bExchangeLeftRight && nSprmId == 0x845d) || ( !bExchangeLeftRight && nSprmId == 0x845e))
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_LEFT_MARGIN : PROP_LEFT_MARGIN,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
else if(eSprmType == SPRM_DEFAULT)
rContext->Insert(
PROP_PARA_RIGHT_MARGIN, true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
//TODO: what happens to the right margins in numberings?
break;
case 18: // sprmPNest
case NS_sprm::LN_PNest: // sprmPNest
//not handled in the old WW8 filter
break;
case NS_sprm::LN_PDxaLeft1: // sprmPDxaLeft1
case 19:
case NS_sprm::LN_PDxaLeft180: // sprmPDxaLeft180
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_FIRST_LINE_INDENT : PROP_FIRST_LINE_OFFSET,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case 20 : // sprmPDyaLine
case NS_sprm::LN_PDyaLine: // sprmPDyaLine
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
{
style::LineSpacing aSpacing;
sal_Int16 nDistance = sal_Int16(nIntValue & 0xffff);
if(nIntValue & 0xffff0000)
{
// single line in Writer is 100, in Word it is 240
aSpacing.Mode = style::LineSpacingMode::PROP;
aSpacing.Height = sal_Int16(sal_Int32(nDistance) * 100 /240);
}
else
{
if(nDistance < 0)
{
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(-nDistance));
}
else if(nDistance >0)
{
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(nDistance));
}
}
rContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case 21 : // legacy version
case NS_sprm::LN_PDyaBefore: // sprmPDyaBefore
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 22 :
case NS_sprm::LN_PDyaAfter: // sprmPDyaAfter
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 23: //sprmPChgTabs
case NS_sprm::LN_PChgTabs: // sprmPChgTabs
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
OSL_ENSURE( false, "unhandled");
//tabs of list level?
break;
case 24: // "sprmPFInTable"
case NS_sprm::LN_PFInTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFInTable
case NS_sprm::LN_PTableDepth: //sprmPTableDepth
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//not handled via sprm but via text( 0x07 )
break;
case 25: // "sprmPTtp" pap.fTtp
case NS_sprm::LN_PFTtp: // sprmPFTtp was: Read_TabRowEnd
break;
case 26: // "sprmPDxaAbs
case NS_sprm::LN_PDxaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaAbs
case 27: //sprmPDyaAbs
case NS_sprm::LN_PDyaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaAbs
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaWidth
case NS_sprm::LN_PPc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPc
case NS_sprm::LN_PBrcTop10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcTop10
case NS_sprm::LN_PBrcLeft10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcLeft10
case NS_sprm::LN_PBrcBottom10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBottom10
case NS_sprm::LN_PBrcRight10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcRight10
case NS_sprm::LN_PBrcBetween10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBetween10
case NS_sprm::LN_PBrcBar10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar10
case NS_sprm::LN_PDxaFromText10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText10
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWr
case NS_ooxml::LN_CT_PrBase_pBdr: //paragraph border
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
resolveSprmProps(rSprm);
break;
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: done: 0, planned: 8, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
{
//in binary format the borders are directly provided in OOXML they are inside of properties
if( IsOOXMLImport() )
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
BorderHandlerPtr pBorderHandler( new BorderHandler( true ) );
pProperties->resolve(*pBorderHandler);
PropertyIds eBorderId = PropertyIds( 0 );
PropertyIds eBorderDistId = PropertyIds( 0 );
switch( nSprmId )
{
case NS_sprm::LN_PBrcTop:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcLeft:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcRight:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcBetween:
/* WRITERFILTERSTATUS: */
//not supported
break;
default:;
}
if( eBorderId )
rContext->Insert( eBorderId, true, uno::makeAny( pBorderHandler->getBorderLine()) , true);
if(eBorderDistId)
rContext->Insert(eBorderDistId, true, uno::makeAny( pBorderHandler->getLineDistance()), true);
}
}
else
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nSprmId )
{
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: */
OSL_ENSURE( false, "TODO: inner border is not handled");
break;
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: */
default:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
}
rContext->Insert(eBorderId, true, uno::makeAny( aBorderLine ));
rContext->Insert(eBorderDistId, true, uno::makeAny( nLineDistance ));
}
}
break;
case NS_sprm::LN_PBorderTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
OSL_ENSURE( false, "TODO: border color definition");
break;
case NS_sprm::LN_PBrcBar:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar
case NS_sprm::LN_PFNoAutoHyph: // sprmPFNoAutoHyph
/* WRITERFILTERSTATUS: done: 100, planned: 1, spent: 0 */
rContext->Insert(PROP_PARA_IS_HYPHENATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWHeightAbs
case NS_sprm::LN_PDcs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDcs
case NS_sprm::LN_PShd: // sprmPShd
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 2 */
{
//contains fore color, back color and shadow percentage, results in a brush
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
CellColorHandlerPtr pCellColorHandler( new CellColorHandler );
pCellColorHandler->setParagraph();
pProperties->resolve(*pCellColorHandler);
rContext->insert( pCellColorHandler->getProperties(), true );
}
}
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaFromText
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText
case NS_sprm::LN_PFLocked:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFLocked
case NS_sprm::LN_PFWidowControl:
case NS_ooxml::LN_CT_PPrBase_widowControl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
uno::Any aVal( uno::makeAny( sal_Int8(nIntValue ? 2 : 0 )));
rContext->Insert( PROP_PARA_WIDOWS, true, aVal );
rContext->Insert( PROP_PARA_ORPHANS, true, aVal );
}
break; // sprmPFWidowControl
case NS_sprm::LN_PRuler:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPRuler
case NS_sprm::LN_PFKinsoku:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFKinsoku
case NS_sprm::LN_PFWordWrap:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFWordWrap
case NS_sprm::LN_PFOverflowPunct: ; // sprmPFOverflowPunct - hanging punctuation
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_PARA_IS_HANGING_PUNCTUATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PFTopLinePunct:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFTopLinePunct
case NS_sprm::LN_PFAutoSpaceDE:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDE
case NS_sprm::LN_PFAutoSpaceDN:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDN
case NS_sprm::LN_PWAlignFont:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWAlignFont
case NS_sprm::LN_PFrameTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFrameTextFlow
case NS_sprm::LN_PISnapBaseLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPISnapBaseLine
case NS_sprm::LN_PAnld:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPAnld
case NS_sprm::LN_PPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPropRMark
case NS_sprm::LN_POutLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPOutLvl
case NS_sprm::LN_PFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFBiDi
case NS_sprm::LN_PFNumRMIns:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFNumRMIns
case NS_sprm::LN_PCrLf:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPCrLf
case NS_sprm::LN_PNumRM:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPNumRM
case NS_sprm::LN_PHugePapx:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPHugePapx
case NS_sprm::LN_PFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFUsePgsuSettings
case NS_sprm::LN_PFAdjustRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAdjustRight
case NS_sprm::LN_CFRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMarkDel
case NS_sprm::LN_CFRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMark
case NS_sprm::LN_CFFldVanish:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFldVanish
case NS_sprm::LN_CFSpec: // sprmCFSpec
break;
case NS_sprm::LN_CPicLocation: // sprmCPicLocation
//is being resolved on the tokenizer side
break;
case NS_sprm::LN_CIbstRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMark
case NS_sprm::LN_CDttmRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMark
case NS_sprm::LN_CFData:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFData
case NS_sprm::LN_CIdslRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMark
case NS_sprm::LN_CChs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCChs
case NS_sprm::LN_CSymbol: // sprmCSymbol
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
resolveSprmProps(rSprm); //resolves LN_FONT and LN_CHAR
break;
case NS_sprm::LN_CFOle2:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFOle2
case NS_sprm::LN_CIdCharType:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdCharType
case NS_sprm::LN_CHighlight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if(true ==( mbIsHighlightSet = getColorFromIndex(nIntValue, nColor)))
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( nColor ));
else if (mnBackgroundColor)
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( mnBackgroundColor ));
}
break; // sprmCHighlight
case NS_sprm::LN_CObjLocation:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCObjLocation
case NS_sprm::LN_CFFtcAsciSymb:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFtcAsciSymb
case NS_sprm::LN_CIstd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstd
case NS_sprm::LN_CIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstdPermute
case NS_sprm::LN_CDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDefault
case NS_sprm::LN_CPlain:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPlain
case NS_sprm::LN_CKcd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_EMPHASIS, true, uno::makeAny ( getEmphasisValue (nIntValue)));
break; // sprmCKcd
case NS_sprm::LN_CFEmboss:// sprmCFEmboss
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi:// sprmCFBoldBi (offset 0x27 to normal bold)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalicBi:// sprmCFItalicBi (offset 0x27 to normal italic)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFBold: //sprmCFBold
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 61: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalic: //sprmCFItalic
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFStrike: //sprmCFStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5*/
case NS_sprm::LN_CFOutline: //sprmCFOutline
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFShadow: //sprmCFShadow
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFSmallCaps: //sprmCFSmallCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFCaps: //sprmCFCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFVanish: //sprmCFVanish
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFDStrike: // sprmCFDStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
{
PropertyIds ePropertyId = PROP_CHAR_WEIGHT; //initialized to prevent warning!
switch( nSprmId )
{
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
case NS_sprm::LN_CFBold: /*sprmCFBold*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId != NS_sprm::LN_CFBoldBi ? PROP_CHAR_WEIGHT : PROP_CHAR_WEIGHT_COMPLEX;
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId == 0x836 ? PROP_CHAR_POSTURE : PROP_CHAR_POSTURE_COMPLEX;
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_STRIKEOUT;
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CONTOURED;
break;
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_SHADOWED;
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CASE_MAP;
break;
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_HIDDEN;
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_RELIEF;
break;
}
//expected: 0,1,128,129
if(nIntValue != 128) //inherited from paragraph - ignore
{
if( nIntValue == 129) //inverted style sheet value
{
//get value from style sheet and invert it
sal_Int16 nStyleValue = 0;
double fDoubleValue;
uno::Any aStyleVal = m_pImpl->GetPropertyFromStyleSheet(ePropertyId);
if( !aStyleVal.hasValue() )
{
nIntValue = 0x83a == nSprmId ?
4 : 1;
}
else if(aStyleVal.getValueTypeClass() == uno::TypeClass_FLOAT )
{
//only in case of awt::FontWeight
aStyleVal >>= fDoubleValue;
nIntValue = fDoubleValue > 100. ? 0 : 1;
}
else if((aStyleVal >>= nStyleValue) ||
(nStyleValue = (sal_Int16)comphelper::getEnumAsINT32(aStyleVal)) >= 0 )
{
nIntValue = 0x83a == nSprmId ?
nStyleValue ? 0 : 4 :
nStyleValue ? 0 : 1;
}
else
{
OSL_ENSURE( false, "what type was it");
}
}
switch( nSprmId )
{
case 60:/*sprmCFBold*/
case NS_sprm::LN_CFBold: /*sprmCFBold*/
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
/* WRITERFILTERSTATUS: */
{
uno::Any aBold( uno::makeAny( nIntValue ? awt::FontWeight::BOLD : awt::FontWeight::NORMAL ) );
rContext->Insert(ePropertyId, true, aBold );
if( nSprmId != NS_sprm::LN_CFBoldBi ) // sprmCFBoldBi
rContext->Insert(PROP_CHAR_WEIGHT_ASIAN, true, aBold );
}
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
/* WRITERFILTERSTATUS: */
{
uno::Any aPosture( uno::makeAny( nIntValue ? awt::FontSlant_ITALIC : awt::FontSlant_NONE ) );
rContext->Insert( ePropertyId, true, aPosture );
if( nSprmId != NS_sprm::LN_CFItalicBi ) // sprmCFItalicBi
rContext->Insert(PROP_CHAR_POSTURE_ASIAN, true, aPosture );
}
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontStrikeout::SINGLE : awt::FontStrikeout::NONE ) );
break;
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( awt::FontStrikeout::DOUBLE ) );
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true, uno::makeAny( nIntValue ? true : false ));
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::SMALLCAPS : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::UPPERCASE : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontRelief::EMBOSSED : awt::FontRelief::NONE ));
break;
}
}
}
break;
case NS_sprm::LN_CFtcDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFtcDefault
case NS_sprm::LN_CKul: // sprmCKul
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
// Parameter: 0 = none, 1 = single, 2 = by Word,
// 3 = double, 4 = dotted, 5 = hidden
// 6 = thick, 7 = dash, 8 = dot(not used)
// 9 = dotdash 10 = dotdotdash 11 = wave
handleUnderlineType(nIntValue, rContext);
}
break;
case NS_sprm::LN_CSizePos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCSizePos
case NS_sprm::LN_CLid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCLid
case NS_sprm::LN_CIco:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if (getColorFromIndex(nIntValue, nColor))
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break; // sprmCIco
case NS_sprm::LN_CHpsBi: // sprmCHpsBi
case NS_sprm::LN_CHps: // sprmCHps
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//multiples of half points (12pt == 24)
double fVal = double(nIntValue) / 2.;
uno::Any aVal = uno::makeAny( fVal );
if( NS_sprm::LN_CHpsBi == nSprmId )
rContext->Insert( PROP_CHAR_HEIGHT_COMPLEX, true, aVal );
else
{
//Asian get the same value as Western
rContext->Insert( PROP_CHAR_HEIGHT, true, aVal );
rContext->Insert( PROP_CHAR_HEIGHT_ASIAN, true, aVal );
}
}
break;
case NS_sprm::LN_CHpsInc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc
case NS_sprm::LN_CHpsPos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
// FIXME: ww8 filter in ww8par6.cxx has a Read_SubSuperProp function
// that counts the escapement from this value and font size. So it will be
// on our TODO list
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 100;
if (nIntValue < 0)
nEscapement = -58;
else if (nIntValue > 0)
nEscapement = 58;
else /* (nIntValue == 0) */
nProp = 0;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break; // sprmCHpsPos
case NS_sprm::LN_CHpsPosAdj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsPosAdj
case NS_sprm::LN_CMajority:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority
case NS_sprm::LN_CIss: // sprmCIss
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//sub/super script 1: super, 2: sub, 0: normal
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
switch(nIntValue)
{
case 1: //super
nEscapement = 101;
break;
case 2: //sub
nEscapement = -101;
break;
case 0: nProp = 0;break; //none
}
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
case NS_sprm::LN_CHpsNew50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsNew50
case NS_sprm::LN_CHpsInc1:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc1
case 71 : //"sprmCDxaSpace"
case 96 : //"sprmCDxaSpace"
case NS_sprm::LN_CDxaSpace: // sprmCDxaSpace
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
//Kerning half point values
//TODO: there are two kerning values -
// in ww8par6.cxx NS_sprm::LN_CHpsKern is used as boolean AutoKerning
rContext->Insert(PROP_CHAR_CHAR_KERNING, true, uno::makeAny( sal_Int16(ConversionHelper::convertTwipToMM100(sal_Int16(nIntValue))) ) );
break;
case NS_sprm::LN_CHpsKern: // sprmCHpsKern auto kerning is bound to a minimum font size in Word - but not in Writer :-(
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_AUTO_KERNING, true, uno::makeAny( true ) );
break;
case NS_sprm::LN_CMajority50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority50
case NS_sprm::LN_CHpsMul:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsMul
case NS_sprm::LN_CYsri:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCYsri
case NS_sprm::LN_CRgFtc0: // sprmCRgFtc0 //ascii font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc1: // sprmCRgFtc1 //Asian font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc2: // sprmCRgFtc2 //CTL font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CFtcBi: // sprmCFtcBi //font index of a CTL font
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
FontTablePtr pFontTable = m_pImpl->GetFontTable();
if(nIntValue >= 0 && pFontTable->size() > sal_uInt32(nIntValue))
{
PropertyIds eFontName = PROP_CHAR_FONT_NAME;
PropertyIds eFontStyle = PROP_CHAR_FONT_STYLE;
PropertyIds eFontFamily = PROP_CHAR_FONT_FAMILY;
PropertyIds eFontCharSet = PROP_CHAR_FONT_CHAR_SET;
PropertyIds eFontPitch = PROP_CHAR_FONT_PITCH;
switch(nSprmId)
{
case NS_sprm::LN_CRgFtc0:
//already initialized
break;
case NS_sprm::LN_CRgFtc1:
eFontName = PROP_CHAR_FONT_NAME_ASIAN;
eFontStyle = PROP_CHAR_FONT_STYLE_ASIAN;
eFontFamily = PROP_CHAR_FONT_FAMILY_ASIAN;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_ASIAN;
eFontPitch = PROP_CHAR_FONT_PITCH_ASIAN;
break;
case NS_sprm::LN_CRgFtc2:
case NS_sprm::LN_CFtcBi:
eFontName = PROP_CHAR_FONT_NAME_COMPLEX;
eFontStyle = PROP_CHAR_FONT_STYLE_COMPLEX;
eFontFamily = PROP_CHAR_FONT_FAMILY_COMPLEX;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_COMPLEX;
eFontPitch = PROP_CHAR_FONT_PITCH_COMPLEX;
break;
}
const FontEntry* pFontEntry = pFontTable->getFontEntry(sal_uInt32(nIntValue));
rContext->Insert(eFontName, true, uno::makeAny( pFontEntry->sFontName ));
// rContext->Insert(eFontStyle, uno::makeAny( pFontEntry-> ));
// rContext->Insert(eFontFamily, uno::makeAny( pFontEntry-> ));
rContext->Insert(eFontCharSet, true, uno::makeAny( (sal_Int16)pFontEntry->nTextEncoding ));
rContext->Insert(eFontPitch, true, uno::makeAny( pFontEntry->nPitchRequest ));
}
}
break;
case NS_sprm::LN_CCharScale: // sprmCCharScale
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_SCALE_WIDTH, true,
uno::makeAny( sal_Int16(nIntValue) ));
break;
case NS_sprm::LN_CFImprint: // sprmCFImprint 1 or 0
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
// FontRelief: NONE, EMBOSSED, ENGRAVED
rContext->Insert(PROP_CHAR_RELIEF, true,
uno::makeAny( nIntValue ? awt::FontRelief::ENGRAVED : awt::FontRelief::NONE ));
break;
case NS_sprm::LN_CFObj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFObj
case NS_sprm::LN_CPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPropRMark
case NS_sprm::LN_CSfxText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// The file-format has many character animations. We have only
// one, so we use it always. Suboptimal solution though.
if (nIntValue)
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( true ));
else
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( false ));
break; // sprmCSfxText
case NS_sprm::LN_CFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFBiDi
case NS_sprm::LN_CFDiacColor:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFDiacColor
case NS_sprm::LN_CIcoBi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIcoBi
case NS_sprm::LN_CDispFldRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDispFldRMark
case NS_sprm::LN_CIbstRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMarkDel
case NS_sprm::LN_CDttmRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMarkDel
case NS_sprm::LN_CBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCBrc
case NS_sprm::LN_CShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCShd
case NS_sprm::LN_CIdslRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMarkDel
case NS_sprm::LN_CFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFUsePgsuSettings
case NS_sprm::LN_CCpg:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCCpg
case NS_sprm::LN_CLidBi: // sprmCLidBi language complex
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid0_80: //sprmCRgLid0_80
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 1 */
//undocumented but interpreted as western language
case NS_sprm::LN_CRgLid0: // sprmCRgLid0 language Western
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid1: // sprmCRgLid1 language Asian
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
lang::Locale aLocale;
MsLangId::convertLanguageToLocale( (LanguageType)nIntValue, aLocale );
rContext->Insert(NS_sprm::LN_CRgLid0 == nSprmId ? PROP_CHAR_LOCALE :
NS_sprm::LN_CRgLid1 == nSprmId ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
case NS_sprm::LN_CIdctHint: // sprmCIdctHint
//list table - text offset???
break;
case NS_sprm::LN_PicBrcl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcl
case NS_sprm::LN_PicScale:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicScale
case NS_sprm::LN_PicBrcTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcTop
case NS_sprm::LN_PicBrcLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcLeft
case NS_sprm::LN_PicBrcBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcBoConversionHelper::convertTwipToMM100ttom
case NS_sprm::LN_PicBrcRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcRight
case NS_sprm::LN_ScnsPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmScnsPgn
case NS_sprm::LN_SiHeadingPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSiHeadingPgn
case NS_sprm::LN_SOlstAnm:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSOlstAnm
case 136:
case NS_sprm::LN_SDxaColWidth: // sprmSDxaColWidth
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// contains the twip width of the column as 3-byte-code
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnWidth( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case NS_sprm::LN_SDxaColSpacing: // sprmSDxaColSpacing
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnSpacing( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case 138:
case NS_sprm::LN_SFEvenlySpaced:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSFEvenlySpaced
case NS_sprm::LN_SFProtected: // sprmSFProtected
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
//todo: missing feature - unlocked sections in protected documents
break;
case NS_sprm::LN_SDmBinFirst: // sprmSDmBinFirst
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetFirstPaperBin(nIntValue);
break;
case NS_sprm::LN_SDmBinOther: // sprmSDmBinOther
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPaperBin( nIntValue );
break;
case NS_sprm::LN_SBkc: // sprmSBkc
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
/* break type
0 - No break
1 - New Colunn
2 - New page
3 - Even page
4 - odd page
*/
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBreakType( nIntValue );
break;
case 143:
case NS_sprm::LN_SFTitlePage: // sprmSFTitlePage
case NS_ooxml::LN_EG_SectPrContents_titlePg:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTitlePage( nIntValue > 0 ? true : false );//section has title page
}
break;
case 144:
case NS_sprm::LN_SCcolumns: // sprmSCcolumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//no of columns - 1
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnCount( (sal_Int16) nIntValue );
break;
case 145:
case NS_sprm::LN_SDxaColumns: // sprmSDxaColumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//column distance - default 708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnDistance( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case NS_sprm::LN_SFAutoPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFAutoPgn
case 147:
case NS_sprm::LN_SNfcPgn: // sprmSNfcPgn
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//page numbering 0 - Arab, 1 - ROMAN, 2 - roman, 3 - ABC, 4 abc
sal_Int16 nNumbering;
switch( nIntValue )
{
case 1: nNumbering = style::NumberingType::ROMAN_UPPER;
case 2: nNumbering = style::NumberingType::ROMAN_LOWER;
case 3: nNumbering = style::NumberingType::CHARS_UPPER_LETTER;
case 4: nNumbering = style::NumberingType::CHARS_LOWER_LETTER;
case 0:
default:
nNumbering = style::NumberingType::ARABIC;
}
rContext->Insert( PROP_NUMBERING_TYPE, false, uno::makeAny( nNumbering ) );
break;
case NS_sprm::LN_SDyaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDyaPgn
case NS_sprm::LN_SDxaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDxaPgn
case 150:
case NS_sprm::LN_SFPgnRestart: // sprmSFPgnRestart
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNoRestart( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFEndnote:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFEndnote
case 154:
case NS_sprm::LN_SNLnnMod:// sprmSNLnnMod
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMod( nIntValue );
break;
case 155:
case NS_sprm::LN_SDxaLnn: // sprmSDxaLnn
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetdxaLnn( nIntValue );
break;
case 152:
case NS_sprm::LN_SLnc:// sprmSLnc
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnc( nIntValue );
break;
case 160:
case NS_sprm::LN_SLnnMin: // sprmSLnnMin
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMin( nIntValue );
break;
case NS_sprm::LN_SGprfIhdt:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
//flags about header/footer sharing and footnotes?
/* ww8scan.hxx:
* WW8_HEADER_EVEN = 0x01, WW8_HEADER_ODD = 0x02, WW8_FOOTER_EVEN = 0x04,
* WW8_FOOTER_ODD = 0x08, WW8_HEADER_FIRST = 0x10, WW8_FOOTER_FIRST = 0x20
*/
// if(pSectionContext)
break; // sprmSGprfIhdt
case NS_sprm::LN_SDyaHdrTop: // sprmSDyaHdrTop
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderTop( ConversionHelper::convertTwipToMM100( nIntValue ));
break;
case NS_sprm::LN_SDyaHdrBottom: // sprmSDyaHdrBottom
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderBottom( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case 158:
case NS_sprm::LN_SLBetween: // sprmSLBetween
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSeparatorLine( nIntValue > 0 );
break;
case NS_sprm::LN_SVjc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSVjc
case 161:
case NS_sprm::LN_SPgnStart: // sprmSPgnStart
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page number
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNumber( nIntValue );
break;
case 162:
case NS_sprm::LN_SBOrientation:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//todo: the old filter assumed that a value of 2 points to double-pages layout
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetLandscape( nIntValue > 0 );
rContext->Insert( PROP_IS_LANDSCAPE , false, uno::makeAny( nIntValue > 0 ));
break; // sprmSBOrientation
case NS_sprm::LN_SBCustomize:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSBCustomize
case 165:
case NS_sprm::LN_SYaPage: // sprmSYaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page height, rounded to default values, default: 0x3dc0 twip
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_HEIGHT, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nHeight ) ) );
}
break;
case NS_sprm::LN_SXaPage: // sprmSXaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page width, rounded to default values, default 0x2fd0 twip
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_WIDTH, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nWidth ) ) );
}
break;
case 166:
case NS_sprm::LN_SDxaLeft: // sprmSDxaLeft
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//left page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetLeftMargin( nConverted );
rContext->Insert( PROP_LEFT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 167:
case NS_sprm::LN_SDxaRight: // sprmSDxaRight
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//right page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetRightMargin( nConverted );
rContext->Insert( PROP_RIGHT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 168:
case NS_sprm::LN_SDyaTop: // sprmSDyaTop
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//top page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_TOP_MARGIN, false, uno::makeAny( nConverted ) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTopMargin( nConverted );
}
break;
case 169:
case NS_sprm::LN_SDyaBottom: // sprmSDyaBottom
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//bottom page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_BOTTOM_MARGIN, false, uno::makeAny( nConverted) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBottomMargin( nConverted );
}
break;
case 170:
case NS_sprm::LN_SDzaGutter: // sprmSDzaGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// gutter is added to one of the margins of a section depending on RTL, can be placed on top either
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDzaGutter( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case NS_sprm::LN_SDmPaperReq: // sprmSDmPaperReq
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//paper code - no handled in old filter
break;
case NS_sprm::LN_SPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSPropRMark
case NS_sprm::LN_SFBiDi:// sprmSFBiDi
{
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSFBiDi( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFFacingCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFFacingCol
case NS_sprm::LN_SFRTLGutter: // sprmSFRTLGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetGutterRTL( nIntValue > 0 );
}
break;
case NS_sprm::LN_SBrcTop: // sprmSBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcLeft: // sprmSBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcBottom: // sprmSBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcRight: // sprmSBrcRight
/* WRITERFILTERSTATUS: Sectiondone: 100, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
static const BorderPosition aPositions[4] =
{
BORDER_TOP,
BORDER_LEFT,
BORDER_BOTTOM,
BORDER_RIGHT
};
pSectionContext->SetBorder( aPositions[nSprmId - NS_sprm::LN_SBrcTop], nLineDistance, aBorderLine );
}
}
break;
case NS_sprm::LN_SPgbProp: // sprmSPgbProp
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->ApplyBorderToPageStyles( m_pImpl->GetPageStyles(), m_pImpl->GetTextFactory(), nIntValue );
}
}
break;
case NS_sprm::LN_SDxtCharSpace:
{
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDxtCharSpace( nIntValue );
}
}
break; // sprmSDxtCharSpace
case NS_sprm::LN_SDyaLinePitch: // sprmSDyaLinePitch
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//see SwWW8ImplReader::SetDocumentGrid
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetGridLinePitch( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case 0x703a: //undocumented, grid related?
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE( false, "TODO: not handled yet"); //nIntValue like 0x008a2373 ?
break;
case NS_sprm::LN_SClm:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
sal_Int16 nGridType = text::TextGridMode::NONE;
switch( nIntValue )
{
case 0:
nGridType = text::TextGridMode::NONE;
break;
case 3:
//Text snaps to char grid, this doesn't make a lot of sense to
//me. This is closer than LINES_CHARS
nGridType = text::TextGridMode::LINES;
break;
case 1:
nGridType = text::TextGridMode::LINES_AND_CHARS;
break;
case 2:
nGridType = text::TextGridMode::LINES;
break;
default:;
}
rContext->Insert( PROP_GRID_MODE, false, uno::makeAny( nGridType ) );
//Seems to force this behaviour in word ?
if(nGridType != text::TextGridMode::NONE)
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_EXTERNAL_LEADING ),
uno::makeAny( true ) );
}
break; // sprmSClm
case NS_sprm::LN_STextFlow:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* 0 HoriLR 1 Vert TR 2 Vert TR 3 Vert TT 4 HoriLT
only 0 and 1 can be imported correctly
*/
sal_Int16 nDirection = text::WritingMode_LR_TB;
switch( nIntValue )
{
case 0:
case 4:
nDirection = text::WritingMode_LR_TB;
break;
case 1:
case 2:
case 3:
nDirection = text::WritingMode_TB_RL;
break;
default:;
}
rContext->Insert(PROP_WRITING_MODE, false, uno::makeAny( nDirection ) );
}
break; // sprmSTextFlow
case NS_sprm::LN_TJc: // sprmTJc
case NS_sprm::LN_TDxaLeft:
case NS_sprm::LN_TDxaGapHalf:
case NS_sprm::LN_TFCantSplit:
case NS_sprm::LN_TTableHeader:
case NS_sprm::LN_TTableBorders: // sprmTTableBorders
{
OSL_ENSURE( false, "table propeties should be handled by the table manager");
}
break;
case NS_sprm::LN_TDefTable10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable10
case NS_sprm::LN_TDyaRowHeight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDyaRowHeight
case NS_sprm::LN_TDefTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable
case NS_sprm::LN_TDefTableShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTableShd
case NS_sprm::LN_TTlp:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTlp
case NS_sprm::LN_TFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTFBiDi
case NS_sprm::LN_THTMLProps:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTHTMLProps
case NS_sprm::LN_TSetBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc
case NS_sprm::LN_TInsert:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTInsert
case NS_sprm::LN_TDelete:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDelete
case NS_sprm::LN_TDxaCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDxaCol
case NS_sprm::LN_TMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTMerge
case NS_sprm::LN_TSplit:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSplit
case NS_sprm::LN_TSetBrc10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc10
case 164: // sprmTSetShd
case NS_sprm::LN_TSetShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShd
case NS_sprm::LN_TSetShdOdd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShdOdd
case NS_sprm::LN_TTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTextFlow
case NS_sprm::LN_TDiagLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDiagLine
case NS_sprm::LN_TVertMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertMerge
case NS_sprm::LN_TVertAlign:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertAlign
// the following are not part of the official documentation
case 0x6870: //TxtForeColor
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//contains a color as 0xTTRRGGBB while SO uses 0xTTRRGGBB
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x4874:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //seems to be a language id for Asian text - undocumented
case 0x6877: //underlining color
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
rContext->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x6815:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case NS_sprm::LN_CIndrsid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x6467:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xF617:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xd634: // sprmTNewSpacing - table spacing ( see WW8TabBandDesc::ProcessSpacing() )
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break;
case NS_sprm::LN_TTRLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x4888:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0x6887:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//properties of list levels - undocumented
break;
case 0xd234:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd235:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd236:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd237:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;//undocumented section properties
case NS_sprm::LN_CEastAsianLayout:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_CT_Tabs_tab:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
m_pImpl->IncorporateTabStop(m_pImpl->m_aCurrentTabStop);
m_pImpl->m_aCurrentTabStop = DeletableTabStop();
break;
case NS_ooxml::LN_CT_PPrBase_tabs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
// Initialize tab stop vector from style sheet
if( !m_pImpl->IsStyleSheetImport() )
{
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
}
resolveSprmProps(rSprm);
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case NS_ooxml::LN_CT_PPr_sectPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_color:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_rFonts:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_bdr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_eastAsianLayout:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_u:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_lang:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_spacing:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_ind:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_RPrDefault_rPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrDefault_pPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_pPrDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_rPrDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_pPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_rPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPr_rPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_numPr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_footnotePr:
/* WRITERFILTERSTATUS: done: 1ß0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_SectPrContents_endnotePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetInFootnoteProperties( NS_ooxml::LN_EG_SectPrContents_footnotePr == nSprmId );
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_lnNumType:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
aSettings.bIsOn = true;
m_pImpl->SetLineNumberSettings( aSettings );
//apply settings at XLineNumberingProperties
try
{
uno::Reference< text::XLineNumberingProperties > xLineNumberingProperties( m_pImpl->GetTextDocument(), uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySet > xLineNumberingPropSet = xLineNumberingProperties->getLineNumberingProperties();
PropertyNameSupplier& rNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_IS_ON ), uno::makeAny(true) );
if( aSettings.nInterval )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_INTERVAL ), uno::makeAny((sal_Int16)aSettings.nInterval) );
if( aSettings.nDistance )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_DISTANCE ), uno::makeAny(aSettings.nDistance) );
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_RESTART_AT_EACH_PAGE ), uno::makeAny(aSettings.bRestartAtEachPage) );
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_CT_PPrBase_framePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pContext.get() )
{
ParagraphPropertyMap* pParaContext = dynamic_cast< ParagraphPropertyMap* >( pContext.get() );
pParaContext->SetFrameMode();
}
else
{
//TODO: What about style sheet import of frame properties
}
resolveSprmProps(rSprm);
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgSz:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = 0;
{
PaperInfo aLetter(PAPER_LETTER);
CT_PageSz.w = aLetter.getWidth();
CT_PageSz.h = aLetter.getHeight();
}
CT_PageSz.orient = false;
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->Insert( PROP_HEIGHT, false, uno::makeAny( CT_PageSz.h ) );
pSectionContext->Insert( PROP_IS_LANDSCAPE, false, uno::makeAny( CT_PageSz.orient ));
pSectionContext->Insert( PROP_WIDTH, false, uno::makeAny( CT_PageSz.w ) );
pSectionContext->SetLandscape( CT_PageSz.orient );
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgMar:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->InitPageMargins();
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
const _PageMar& rPageMar = m_pImpl->GetPageMargins();
pSectionContext->SetTopMargin( rPageMar.top );
pSectionContext->SetRightMargin( rPageMar.right );
pSectionContext->SetBottomMargin( rPageMar.bottom );
pSectionContext->SetLeftMargin( rPageMar.left );
pSectionContext->SetHeaderTop( rPageMar.header );
pSectionContext->SetHeaderBottom( rPageMar.footer );
}
break;
case NS_ooxml::LN_EG_SectPrContents_cols:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
SectionColumnHandlerPtr pSectHdl( new SectionColumnHandler );
pProperties->resolve(*pSectHdl);
if(pSectionContext)
{
if( pSectHdl->IsEqualWidth() )
{
pSectionContext->SetEvenlySpaced( true );
pSectionContext->SetColumnCount( (sal_Int16) (pSectHdl->GetNum() - 1) );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( !pSectHdl->GetColumns().empty() )
{
pSectionContext->SetEvenlySpaced( false );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetColumnCount( (sal_Int16)(pSectHdl->GetColumns().size() -1));
std::vector<_Column>::const_iterator tmpIter = pSectHdl->GetColumns().begin();
for (; tmpIter != pSectHdl->GetColumns().end(); tmpIter++)
{
pSectionContext->AppendColumnWidth( tmpIter->nWidth );
if ((tmpIter != pSectHdl->GetColumns().end() - 1) || (tmpIter->nSpace > 0))
pSectionContext->AppendColumnSpacing( tmpIter->nSpace );
}
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( pSectHdl->GetNum() > 0 )
{
pSectionContext->SetColumnCount( (sal_Int16)pSectHdl->GetNum() - 1 );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
}
}
}
}
break;
case NS_ooxml::LN_CT_PPrBase_pStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
m_pImpl->SetCurrentParaStyleId( sStringValue );
StyleSheetTablePtr pStyleTable = m_pImpl->GetStyleSheetTable();
const ::rtl::OUString sConvertedStyleName = pStyleTable->ConvertStyleName( sStringValue, true );
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sConvertedStyleName ));
const StyleSheetEntry* pEntry = pStyleTable->FindStyleSheetByISTD(sStringValue);
//apply numbering to paragraph if it was set at the style
OSL_ENSURE( pEntry, "no style sheet found" );
const StyleSheetPropertyMap* pStyleSheetProperties = dynamic_cast<const StyleSheetPropertyMap*>(pEntry ? pEntry->pProperties.get() : 0);
if( pStyleSheetProperties && pStyleSheetProperties->GetListId() >= 0 )
rContext->Insert( PROP_NUMBERING_RULES, true, uno::makeAny(m_pImpl->GetListTable()->GetNumberingRules(pStyleSheetProperties->GetListId())), false);
if( pStyleSheetProperties && pStyleSheetProperties->GetListLevel() >= 0 )
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny(pStyleSheetProperties->GetListLevel()), false);
}
break;
case NS_ooxml::LN_EG_RPrBase_rStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert( PROP_CHAR_STYLE_NAME, true, uno::makeAny( m_pImpl->GetStyleSheetTable()->ConvertStyleName( sStringValue, true )));
break;
case NS_ooxml::LN_CT_TblPrBase_tblCellMar: //cell margins
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);//contains LN_CT_TblCellMar_top, LN_CT_TblCellMar_left, LN_CT_TblCellMar_bottom, LN_CT_TblCellMar_right
}
break;
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
MeasureHandlerPtr pMeasureHandler( new MeasureHandler );
pProperties->resolve(*pMeasureHandler);
sal_Int32 nMeasureValue = pMeasureHandler->getMeasureValue();
PropertyIds eId = META_PROP_CELL_MAR_TOP;
switch(nSprmId)
{
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: */
break;
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_LEFT;
break;
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_BOTTOM;
break;
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_RIGHT;
break;
default:;
}
rContext->Insert( eId, false, uno::makeAny(nMeasureValue), false);
}
}
break;
case NS_sprm::LN_CFNoProof: //0x875 no grammar and spell checking, unsupported
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_anchor_anchor: // at_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_inline_inline: // as_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
GraphicImportType eGraphicType =
(NS_ooxml::LN_anchor_anchor ==
sal::static_int_cast<Id>(nSprmId)) ?
IMPORT_AS_DETECTED_ANCHOR :
IMPORT_AS_DETECTED_INLINE;
GraphicImportPtr pGraphicImport =
m_pImpl->GetGraphicImport(eGraphicType);
pProperties->resolve(*pGraphicImport);
m_pImpl->ImportGraphic(pProperties, eGraphicType);
if( !pGraphicImport->IsGraphic() )
{
m_pImpl->ResetGraphicImport();
// todo: It's a shape, now start shape import
}
}
}
break;
case NS_ooxml::LN_EG_RPrBase_vertAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
if( sStringValue.equalsAscii( "superscript" ))
nEscapement = 101;
else if( sStringValue.equalsAscii( "subscript" ))
nEscapement = -101;
else
nProp = 100;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
// case NS_ooxml::LN_CT_FtnEdn_type
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnEdn_id
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_EG_FtnEdnNumProps_numRestart
case NS_ooxml::LN_CT_FtnProps_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnotes in word can be at page end or beneath text - writer supports only the first
//endnotes in word can be at section end or document end - writer supports only the latter
// -> so this property can be ignored
break;
case NS_ooxml::LN_EG_FtnEdnNumProps_numStart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_FtnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_EdnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
try
{
uno::Reference< beans::XPropertySet > xFtnEdnSettings;
if( m_pImpl->IsInFootnoteProperties() )
{
uno::Reference< text::XFootnotesSupplier> xFootnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xFootnotesSupplier->getFootnoteSettings();
}
else
{
uno::Reference< text::XEndnotesSupplier> xEndnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xEndnotesSupplier->getEndnoteSettings();
}
if( NS_ooxml::LN_EG_FtnEdnNumProps_numStart == nSprmId )
{
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_START_AT),
uno::makeAny( sal_Int16( nIntValue - 1 )));
}
else
{
sal_Int16 nNumType = ConversionHelper::ConvertNumberingType( nIntValue );
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_NUMBERING_TYPE),
uno::makeAny( nNumType ));
}
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_trackchange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
case NS_ooxml::LN_EG_RPrContent_rPrChange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
{
resolveSprmProps( rSprm );
// now the properties author, date and id should be available
::rtl::OUString sAuthor = m_pImpl->GetCurrentRedlineAuthor();
::rtl::OUString sDate = m_pImpl->GetCurrentRedlineDate();
::rtl::OUString sId = m_pImpl->GetCurrentRedlineId();
sal_Int32 nToken = m_pImpl->GetCurrentRedlineToken();
switch( nToken & 0xffff )
{
case ooxml::OOXML_mod :
case ooxml::OOXML_ins :
case ooxml::OOXML_del : break;
default: OSL_ENSURE( false, "redline token other than mod, ins or del" );
}
}
break;
case NS_ooxml::LN_CT_RPrChange_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
break;
/* WRITERFILTERSTATUS: done: 0, planned: 4, spent: 0 */
case NS_ooxml::LN_object:
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
OLEHandlerPtr pOLEHandler( new OLEHandler );
pProperties->resolve(*pOLEHandler);
::rtl::OUString sStreamName = pOLEHandler->copyOLEOStream( m_pImpl->GetTextDocument() );
if(sStreamName.getLength())
{
m_pImpl->appendOLE( sStreamName, pOLEHandler );
}
}
}
break;
// case NS_ooxml::LN_CT_EdnProps_pos
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnProps_numFmt
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnDocProps_footnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnDocProps_endnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//break;
case NS_ooxml::LN_EG_HdrFtrReferences_headerReference: // header reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_HdrFtrReferences_footerReference: // footer reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_EG_RPrBase_snapToGrid: // "Use document grid settings for inter-paragraph spacing"
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_sprm::LN_PContextualSpacing:
//TODO: determines whether top/bottom paragraph spacing is added if equal styles are following - unsupported
break;
case NS_ooxml::LN_EG_SectPrContents_formProt: //section protection, only form editing is enabled - unsupported
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Lvl_pStyle:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//TODO: numbering style should apply current numbering level - not yet supported
break;
default:
{
#if OSL_DEBUG_LEVEL > 0
::rtl::OString sMessage( "DomainMapper::sprm() - Id: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nSprmId ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nSprmId ), 16 );
OSL_ENSURE( false, sMessage.getStr()); //
#endif
}
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("sprm");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::entry(int /*pos*/,
writerfilter::Reference<Properties>::Pointer_t ref)
{
ref->resolve(*this);
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::data(const sal_uInt8* /*buf*/, size_t /*len*/,
writerfilter::Reference<Properties>::Pointer_t /*ref*/)
{
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startSectionGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("section");
#endif
m_pImpl->PushProperties(CONTEXT_SECTION);
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endSectionGroup()
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_SECTION);
SectionPropertyMap* pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->CloseSectionGroup( *m_pImpl );
m_pImpl->PopProperties(CONTEXT_SECTION);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("section");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startParagraphGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("paragraph");
#endif
m_pImpl->getTableManager().startParagraphGroup();
m_pImpl->PushProperties(CONTEXT_PARAGRAPH);
static ::rtl::OUString sDefault( ::rtl::OUString::createFromAscii("Standard") );
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sDefault ) );
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
}
m_pImpl->clearDeferredBreaks();
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endParagraphGroup()
{
//handle unprocessed deferred breaks
PropertyMapPtr pParaProperties = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pParaProperties->hasEmptyPropertyValues() )
{
PropertyMap::const_iterator aIter = pParaProperties->find(PropertyDefinition( PROP_BREAK_TYPE , false ) );
if( aIter != pParaProperties->end() )
{
style::BreakType eType;
aIter->second >>= eType;
bool bPage = false;
bool bColumn = false;
if( eType == style::BreakType_PAGE_BEFORE )
bPage = true;
else if( eType == style::BreakType_COLUMN_BEFORE )
bColumn = true;
if( bPage || bColumn )
{
try
{
uno::Reference< beans::XPropertySet > xRangeProperties( m_pImpl->GetTopTextAppend()->getEnd(), uno::UNO_QUERY_THROW );
xRangeProperties->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_BREAK_TYPE),
uno::makeAny( bPage ? style::BreakType_PAGE_BEFORE : style::BreakType_COLUMN_BEFORE));
}
catch( const uno::Exception& )
{
}
}
}
}
m_pImpl->PopProperties(CONTEXT_PARAGRAPH);
m_pImpl->getTableManager().endParagraphGroup();
//frame conversion has to be executed after table conversion
m_pImpl->ExecuteFrameConversion();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("paragraph");
#endif
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushStyleSheetProperties( PropertyMapPtr pStyleProperties )
{
m_pImpl->PushStyleProperties( pStyleProperties );
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopStyleSheetProperties()
{
m_pImpl->PopProperties( CONTEXT_STYLESHEET );
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushListProperties( ::boost::shared_ptr<PropertyMap> pListProperties )
{
m_pImpl->PushListProperties( pListProperties );
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopListProperties()
{
m_pImpl->PopProperties( CONTEXT_LIST );
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startCharacterGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("charactergroup");
#endif
m_pImpl->PushProperties(CONTEXT_CHARACTER);
DomainMapperTableManager& rTableManager = m_pImpl->getTableManager();
if( rTableManager.getTableStyleName().getLength() )
{
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
rTableManager.CopyTextProperties(pTopContext, m_pImpl->GetStyleSheetTable());
}
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endCharacterGroup()
{
m_pImpl->PopProperties(CONTEXT_CHARACTER);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("charactergroup");
#endif
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::text(const sal_uInt8 * data_, size_t len)
{
//TODO: Determine the right text encoding (FIB?)
::rtl::OUString sText( (const sal_Char*) data_, len, RTL_TEXTENCODING_MS_1252 );
try
{
if(len == 1)
{
switch(*data_)
{
case 0x02: return; //footnote character
case 0x0c: //page break
m_pImpl->deferBreak(PAGE_BREAK);
return;
case 0x0e: //column break
m_pImpl->deferBreak(COLUMN_BREAK);
return;
case 0x07:
m_pImpl->getTableManager().text(data_, len);
case 0x0d:
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
return;
case 0x13:
m_pImpl->PushFieldContext();
return;
case 0x14:
// delimiter not necessarily available
// appears only if field contains further content
m_pImpl->CloseFieldCommand();
return;
case 0x15: /* end of field */
m_pImpl->PopFieldContext();
return;
default:
break;
}
}
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
if( pContext->GetFootnote().is() && m_pImpl->IsCustomFtnMark() )
{
pContext->GetFootnote()->setLabel( sText );
m_pImpl->SetCustomFtnMark( false );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
{
//--> debug
//sal_uInt32 nSize = pContext->size();
//<--
m_pImpl->appendTextPortion( sText, pContext );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("text");
dmapper_logger->chars(sText);
dmapper_logger->endElement("text");
#endif
}
}
catch( const uno::RuntimeException& )
{
std::clog << __FILE__ << "(l" << __LINE__ << ")" << std::endl;
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::utext(const sal_uInt8 * data_, size_t len)
{
OUString sText;
OUStringBuffer aBuffer = OUStringBuffer(len);
aBuffer.append( (const sal_Unicode *) data_, len);
sText = aBuffer.makeStringAndClear();
try
{
m_pImpl->getTableManager().utext(data_, len);
if(len == 1 && ((*data_) == 0x0d || (*data_) == 0x07))
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
else
{
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
/* doesn't seem to be working
if( pContext->GetFootnote().is() )
{
//todo: the check for 0x0a is a hack!
if( *data_ != 0x0a && !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else */
if( pContext && pContext->GetFootnote().is() )
{
if( !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
m_pImpl->appendTextPortion( sText, pContext );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("utext");
dmapper_logger->chars(sText);
dmapper_logger->endElement("utext");
#endif
}
}
catch( const uno::RuntimeException& )
{
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::props(writerfilter::Reference<Properties>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("props");
#endif
string sType = ref->getType();
if( sType == "PICF" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_GRAPHIC);
}
else if( sType == "FSPA" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_SHAPE);
}
else
ref->resolve(*this);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("props");
#endif
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("table");
dmapper_logger->attribute("id", (*QNameToString::Instance())(name));
#endif
// printf ( "DomainMapper::table(0x%.4x)\n", (unsigned int)name);
m_pImpl->SetAnyTableImport(true);
/* WRITERFILTERSTATUS: table: attributedata */
switch(name)
{
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// create a font table object that listens to the attributes
// each entry call inserts a new font entry
ref->resolve( *m_pImpl->GetFontTable() );
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//same as above to import style sheets
m_pImpl->SetStyleSheetImport( true );
ref->resolve( *m_pImpl->GetStyleSheetTable() );
m_pImpl->GetStyleSheetTable()->ApplyStyleSheets(m_pImpl->GetFontTable());
m_pImpl->SetStyleSheetImport( false );
break;
case NS_ooxml::LN_NUMBERING:
case NS_rtf::LN_LISTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//the same for list tables
ref->resolve( *m_pImpl->GetListTable() );
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
ref->resolve( *m_pImpl->GetLFOTable() );
break;
case NS_ooxml::LN_THEMETABLE:
ref->resolve ( *m_pImpl->GetThemeTable() );
break;
case NS_ooxml::LN_settings_settings:
ref->resolve ( *m_pImpl->GetSettingsTable() );
m_pImpl->ApplySettingsTable();
break;
default:
OSL_ENSURE( false, "which table is to be filled here?");
}
m_pImpl->SetAnyTableImport(false);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("table");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::substream(Id rName, ::writerfilter::Reference<Stream>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("substream");
#endif
m_pImpl->getTableManager().startLevel();
//->debug
//string sName = (*QNameToString::Instance())(rName);
//--<debug
//import of page header/footer
/* WRITERFILTERSTATUS: table: attributedata */
switch( rName )
{
case NS_rtf::LN_headerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_headerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_footerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PushFootOrEndnote( NS_rtf::LN_footnote == rName );
break;
case NS_rtf::LN_annotation :
m_pImpl->PushAnnotation();
break;
}
ref->resolve(*this);
switch( rName )
{
case NS_rtf::LN_headerl:
case NS_rtf::LN_headerr:
case NS_rtf::LN_headerf:
case NS_rtf::LN_footerl:
case NS_rtf::LN_footerr:
case NS_rtf::LN_footerf:
m_pImpl->PopPageHeaderFooter();
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PopFootOrEndnote();
break;
case NS_rtf::LN_annotation :
m_pImpl->PopAnnotation();
break;
}
m_pImpl->getTableManager().endLevel();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("substream");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::info(const string & /*info_*/)
{
}
void DomainMapper::handleUnderlineType(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext)
{
sal_Int16 eUnderline = awt::FontUnderline::NONE;
switch(nIntValue)
{
case 0: eUnderline = awt::FontUnderline::NONE; break;
case 2: pContext->Insert(PROP_CHAR_WORD_MODE, true, uno::makeAny( true ) ); // TODO: how to get rid of it?
case 1: eUnderline = awt::FontUnderline::SINGLE; break;
case 3: eUnderline = awt::FontUnderline::DOUBLE; break;
case 4: eUnderline = awt::FontUnderline::DOTTED; break;
case 7: eUnderline = awt::FontUnderline::DASH; break;
case 9: eUnderline = awt::FontUnderline::DASHDOT; break;
case 10:eUnderline = awt::FontUnderline::DASHDOTDOT; break;
case 6: eUnderline = awt::FontUnderline::BOLD; break;
case 11:eUnderline = awt::FontUnderline::WAVE; break;
case 20:eUnderline = awt::FontUnderline::BOLDDOTTED; break;
case 23:eUnderline = awt::FontUnderline::BOLDDASH; break;
case 39:eUnderline = awt::FontUnderline::LONGDASH; break;
case 55:eUnderline = awt::FontUnderline::BOLDLONGDASH; break;
case 25:eUnderline = awt::FontUnderline::BOLDDASHDOT; break;
case 26:eUnderline = awt::FontUnderline::BOLDDASHDOTDOT;break;
case 27:eUnderline = awt::FontUnderline::BOLDWAVE; break;
case 43:eUnderline = awt::FontUnderline::DOUBLEWAVE; break;
default: ;
}
pContext->Insert(PROP_CHAR_UNDERLINE, true, uno::makeAny( eUnderline ) );
}
void DomainMapper::handleParaJustification(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext, const bool bExchangeLeftRight)
{
sal_Int16 nAdjust = 0;
sal_Int16 nLastLineAdjust = 0;
switch(nIntValue)
{
case 1:
nAdjust = style::ParagraphAdjust_CENTER;
break;
case 2:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_LEFT : style::ParagraphAdjust_RIGHT);
break;
case 4:
nLastLineAdjust = style::ParagraphAdjust_BLOCK;
//no break;
case 3:
nAdjust = style::ParagraphAdjust_BLOCK;
break;
case 0:
default:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_RIGHT : style::ParagraphAdjust_LEFT);
break;
}
pContext->Insert( PROP_PARA_ADJUST, true, uno::makeAny( nAdjust ) );
pContext->Insert( PROP_PARA_LAST_LINE_ADJUST, true, uno::makeAny( nLastLineAdjust ) );
}
bool DomainMapper::getColorFromIndex(const sal_Int32 nIndex, sal_Int32 &nColor)
{
nColor = 0;
if ((nIndex < 1) || (nIndex > 16))
return false;
switch (nIndex)
{
case 1: nColor=0x000000; break; //black
case 2: nColor=0x0000ff; break; //blue
case 3: nColor=0x00ffff; break; //cyan
case 4: nColor=0x00ff00; break; //green
case 5: nColor=0xff00ff; break; //magenta
case 6: nColor=0xff0000; break; //red
case 7: nColor=0xffff00; break; //yellow
case 8: nColor=0xffffff; break; //white
case 9: nColor=0x000080; break;//dark blue
case 10: nColor=0x008080; break; //dark cyan
case 11: nColor=0x008000; break; //dark green
case 12: nColor=0x800080; break; //dark magenta
case 13: nColor=0x800000; break; //dark red
case 14: nColor=0x808000; break; //dark yellow
case 15: nColor=0x808080; break; //dark gray
case 16: nColor=0xC0C0C0; break; //light gray
default:
return false;
}
return true;
}
sal_Int16 DomainMapper::getEmphasisValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1:
return com::sun::star::text::FontEmphasis::DOT_ABOVE;
case 2:
return com::sun::star::text::FontEmphasis::ACCENT_ABOVE;
case 3:
return com::sun::star::text::FontEmphasis::CIRCLE_ABOVE;
case 4:
return com::sun::star::text::FontEmphasis::DOT_BELOW;
default:
return com::sun::star::text::FontEmphasis::NONE;
}
}
rtl::OUString DomainMapper::getBracketStringFromEnum(const sal_Int32 nIntValue, const bool bIsPrefix)
{
switch(nIntValue)
{
case 1:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "(" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ")" ));
case 2:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "[" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "]" ));
case 3:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "<" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ">" ));
case 4:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "{" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "}" ));
case 0:
default:
return rtl::OUString();
}
}
void DomainMapper::resolveSprmProps(Sprm & rSprm)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
pProperties->resolve(*this);
}
void DomainMapper::resolveAttributeProperties(Value & val)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
pProperties->resolve(*this);
}
com::sun::star::style::TabAlign DomainMapper::getTabAlignFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 0:
case 4: // bar not supported
return com::sun::star::style::TabAlign_LEFT;
case 1:
return com::sun::star::style::TabAlign_CENTER;
case 2:
return com::sun::star::style::TabAlign_RIGHT;
case 3:
return com::sun::star::style::TabAlign_DECIMAL;
default:
return com::sun::star::style::TabAlign_DEFAULT;
}
return com::sun::star::style::TabAlign_LEFT;
}
sal_Unicode DomainMapper::getFillCharFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1: // dot
return sal_Unicode(0x002e);
case 2: // hyphen
return sal_Unicode(0x002d);
case 3: // underscore
case 4: // heavy FIXME ???
return sal_Unicode(0x005f);
case NS_ooxml::LN_Value_ST_TabTlc_middleDot: // middleDot
return sal_Unicode(0x00b7);
case 0: // none
default:
return sal_Unicode(0x0020); // blank space
}
}
/*-- 18.07.2007 14:59:00---------------------------------------------------
-----------------------------------------------------------------------*/
bool DomainMapper::IsOOXMLImport() const
{
return m_pImpl->IsOOXMLImport();
}
/*-- 18.07.2007 16:03:14---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference < lang::XMultiServiceFactory > DomainMapper::GetTextFactory() const
{
return m_pImpl->GetTextFactory();
}
/*-- 12.11.2007 10:41:01---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::AddListIDToLFOTable( sal_Int32 nAbstractNumId )
{
m_pImpl->GetLFOTable()->AddListID( nAbstractNumId );
}
/*-- 31.01.2008 18:19:44---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference< text::XTextRange > DomainMapper::GetCurrentTextRange()
{
return m_pImpl->GetTopTextAppend()->getEnd();
}
/*-- 05.02.2008 10:26:26---------------------------------------------------
-----------------------------------------------------------------------*/
::rtl::OUString DomainMapper::getOrCreateCharStyle( PropertyValueVector_t& rCharProperties )
{
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
return pStyleSheets->getOrCreateCharStyle( rCharProperties );
}
} //namespace dmapper
} //namespace writerfilter
|
#include "DRAW.H"
#include "CONTROL.H"
#if PSX_VERSION || PSXPC_VERSION || SAT_VERSION
#include "DRAWSPKS.H"
#include "SETUP.H"
#include "MATHS.H"
#endif
#include "OBJECTS.H"
#include "SPECIFIC.H"
#include "STYPES.H"
#include "TOMB4FX.H"
#include <stddef.h>
//#include <INLINE_O.H>
#if PSX_VERSION || PSXPC_VERSION || SAT_VERSION
#include "MISC.H"
#endif
short LightningSFXDelay;
struct room_info* room;
short number_rooms;
long* bones;
struct ANIM_STRUCT* anims;
struct RANGE_STRUCT* ranges;
struct CHANGE_STRUCT* changes;
short** meshes;
short* commands;
short* frames;
short* binoculars_mesh_ptr;
short* target_mesh_ptr;
short SkyPos;
short SkyPos2;
int number_draw_rooms;
short draw_rooms[100];
int number_dynamics;
long camera_underwater;
long gfMirrorZPlane;
unsigned short LightningRGBs[3];
unsigned short LightningRGB[3];
short LightningCount;
short LightningRand;
short dLightningRand;
short interpolated_bounds[6];
short* GLOBAL_gunflash_meshptr;
int CurrentRoom;
unsigned char CreditsDone;
short GlobalRoomNumber;
long outside;
long outside_left;
long outside_right;
long outside_top;
long outside_bottom;
short HorizonClip;
struct door_vbuf vbufdoor[4];
short Sback_gun;
short* SRhandPtr;
short* SLhandPtr;
#if PC_VERSION || PSXPC_TEST
long GetFrames(struct ITEM_INFO* item/*$a0*/, short* frames[]/*a1*/, int* rate/*$a2*/)//8582C
{
struct ANIM_STRUCT* anim = &anims[item->anim_number];
int t3;
short* t4;
rate[0] = anim->interpolation;
t3 = ((item->frame_number - anim->frame_base) / anim->interpolation) * anim->interpolation >> 8;
t4 = &anim->frame_ptr[t3];
frames[0] = &anim->frame_ptr[t3];
frames[1] = &t4[anim->interpolation >> 8];
if (anim->interpolation == 0)
{
return 0;
}
t3 = ((item->frame_number - anim->frame_base) / anim->interpolation) * anim->interpolation;
if (!(anim->frame_end < (t3 + anim->interpolation)))
{
return (t3 + anim->interpolation) - anim->interpolation;
}
rate[0] = anim->frame_end - anim->interpolation;
return (item->frame_number - anim->frame_base) / anim->interpolation;
}
#endif
void UpdateSkyLightning()//2C0D0(<), ? (F)
{
long lp;
if (LightningCount > 0)
{
--LightningCount;
if ((LightningCount << 16) == 0)
{
LightningRand = (GetRandomDraw() & 0x7F) + 400;
dLightningRand = 0;
}
else
{
//loc_2C118
dLightningRand = (GetRandomDraw() & 0x1FF);
LightningRand = ((dLightningRand - LightningRand) >> 1) + LightningRand;
}
}
else
{
//loc_2C148
if (LightningRand < 4)
{
//loc_2C174
LightningRand = 0;
}
else
{
LightningRand = LightningRand - (LightningRand >> 2);
}
}
//loc_2C18C
for (lp = 2; lp >= 0; lp--)
{
LightningRGBs[lp] += ((LightningRGBs[lp] * LightningRand) >> 8);
if ((LightningRGBs[lp] & 0xFFFF) > 255)
{
LightningRGBs[lp] = 255;
}
}
}
void DrawSkyMesh(short* mesh)
{
UNIMPLEMENTED();
}
void DrawMoon()
{
UNIMPLEMENTED();
}
void DrawGunflashes()//8A924(<) 8C968(<)
{
#ifdef PC_VERSION
UNIMPLEMENTED();
#else
long rand;
long i;
short* mesh;
if (!Gunflashes[0].on)
{
return;
}
mPushMatrix();
rand = (GetRandomDraw() & 0x1F);
/*SetInventoryLighting(((GetRandomDraw() & 0xF) + 72) | 0x4000,
((GetRandomDraw() & 0xF) + 72) | 0x4000,
((GetRandomDraw() & 0xF) + 72) | 0x4000,
rand << 16 | rand << 8 | rand);*/
for (i = 0; i < 4; i++)
{
if (Gunflashes[i].on)
{
mCopyMatrix(&Gunflashes[i].matrix);
//mRotZ(GetRandomDraw() << 1);
mesh = meshes[objects[GUN_FLASH].mesh_index];
//phd_PutPolygons(((long*) mesh)[0], -1);
mesh[16] = 0;
}
}
mPopMatrix();
#endif
}
short* GetBestFrame(struct ITEM_INFO* item)// (F)s
{
short* frm[2];
int rate;
const int ret = GetFrames(item, frm, &rate);
if (ret > (rate >> 1))
return frm[1];
else
return frm[0];
}
void DrawAnimatingItem(struct ITEM_INFO *item)
{
UNIMPLEMENTED();
}
Fix PSX compile
#include "DRAW.H"
#include "CONTROL.H"
#if PSX_VERSION || PSXPC_VERSION || SAT_VERSION
#include "DRAWSPKS.H"
#include "SETUP.H"
#include "MATHS.H"
#endif
#include "OBJECTS.H"
#include "SPECIFIC.H"
#include "STYPES.H"
#include "TOMB4FX.H"
#include <stddef.h>
//#include <INLINE_O.H>
#if PSX_VERSION || PSXPC_VERSION || SAT_VERSION
#include "MISC.H"
#endif
short LightningSFXDelay;
struct room_info* room;
short number_rooms;
long* bones;
struct ANIM_STRUCT* anims;
struct RANGE_STRUCT* ranges;
struct CHANGE_STRUCT* changes;
short** meshes;
short* commands;
short* frames;
short* binoculars_mesh_ptr;
short* target_mesh_ptr;
short SkyPos;
short SkyPos2;
int number_draw_rooms;
short draw_rooms[100];
int number_dynamics;
long camera_underwater;
long gfMirrorZPlane;
unsigned short LightningRGBs[3];
unsigned short LightningRGB[3];
short LightningCount;
short LightningRand;
short dLightningRand;
short interpolated_bounds[6];
short* GLOBAL_gunflash_meshptr;
int CurrentRoom;
unsigned char CreditsDone;
short GlobalRoomNumber;
long outside;
long outside_left;
long outside_right;
long outside_top;
long outside_bottom;
short HorizonClip;
struct door_vbuf vbufdoor[4];
short Sback_gun;
short* SRhandPtr;
short* SLhandPtr;
#if PC_VERSION || PSXPC_TEST
long GetFrames(struct ITEM_INFO* item/*$a0*/, short* frames[]/*a1*/, int* rate/*$a2*/)//8582C
{
struct ANIM_STRUCT* anim = &anims[item->anim_number];
int t3;
short* t4;
rate[0] = anim->interpolation;
t3 = ((item->frame_number - anim->frame_base) / anim->interpolation) * anim->interpolation >> 8;
t4 = &anim->frame_ptr[t3];
frames[0] = &anim->frame_ptr[t3];
frames[1] = &t4[anim->interpolation >> 8];
if (anim->interpolation == 0)
{
return 0;
}
t3 = ((item->frame_number - anim->frame_base) / anim->interpolation) * anim->interpolation;
if (!(anim->frame_end < (t3 + anim->interpolation)))
{
return (t3 + anim->interpolation) - anim->interpolation;
}
rate[0] = anim->frame_end - anim->interpolation;
return (item->frame_number - anim->frame_base) / anim->interpolation;
}
#endif
void UpdateSkyLightning()//2C0D0(<), ? (F)
{
long lp;
if (LightningCount > 0)
{
--LightningCount;
if ((LightningCount << 16) == 0)
{
LightningRand = (GetRandomDraw() & 0x7F) + 400;
dLightningRand = 0;
}
else
{
//loc_2C118
dLightningRand = (GetRandomDraw() & 0x1FF);
LightningRand = ((dLightningRand - LightningRand) >> 1) + LightningRand;
}
}
else
{
//loc_2C148
if (LightningRand < 4)
{
//loc_2C174
LightningRand = 0;
}
else
{
LightningRand = LightningRand - (LightningRand >> 2);
}
}
//loc_2C18C
for (lp = 2; lp >= 0; lp--)
{
LightningRGBs[lp] += ((LightningRGBs[lp] * LightningRand) >> 8);
if ((LightningRGBs[lp] & 0xFFFF) > 255)
{
LightningRGBs[lp] = 255;
}
}
}
#if PC_VERSION || PSXPC_TEST
void DrawSkyMesh(short* mesh)
{
UNIMPLEMENTED();
}
void DrawMoon()
{
UNIMPLEMENTED();
}
#endif
void DrawGunflashes()//8A924(<) 8C968(<)
{
#ifdef PC_VERSION
UNIMPLEMENTED();
#else
long rand;
long i;
short* mesh;
if (!Gunflashes[0].on)
{
return;
}
mPushMatrix();
rand = (GetRandomDraw() & 0x1F);
/*SetInventoryLighting(((GetRandomDraw() & 0xF) + 72) | 0x4000,
((GetRandomDraw() & 0xF) + 72) | 0x4000,
((GetRandomDraw() & 0xF) + 72) | 0x4000,
rand << 16 | rand << 8 | rand);*/
for (i = 0; i < 4; i++)
{
if (Gunflashes[i].on)
{
mCopyMatrix(&Gunflashes[i].matrix);
//mRotZ(GetRandomDraw() << 1);
mesh = meshes[objects[GUN_FLASH].mesh_index];
//phd_PutPolygons(((long*) mesh)[0], -1);
mesh[16] = 0;
}
}
mPopMatrix();
#endif
}
short* GetBestFrame(struct ITEM_INFO* item)// (F)s
{
short* frm[2];
int rate;
const int ret = GetFrames(item, frm, &rate);
if (ret > (rate >> 1))
return frm[1];
else
return frm[0];
}
void DrawAnimatingItem(struct ITEM_INFO *item)
{
UNIMPLEMENTED();
} |
/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// See docs in ../ops/array_ops.cc.
#ifdef INTEL_MKL
#ifndef INTEL_MKL_ML_ONLY
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/register_types.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/kernels/ops_util.h"
#include "tensorflow/core/lib/core/status.h"
#include "tensorflow/core/lib/gtl/array_slice.h"
#include "tensorflow/core/platform/prefetch.h"
#include "third_party/eigen3/unsupported/Eigen/CXX11/Tensor"
#include "mkldnn.hpp"
#include "tensorflow/core/util/mkl_util.h"
using mkldnn::stream;
using mkldnn::view;
namespace tensorflow {
namespace {
gtl::InlinedVector<int64, 4> IntTensorToInt64Vec(const Tensor& tensor) {
gtl::InlinedVector<int64, 4> out;
if (tensor.dtype() == DT_INT32) {
for (int64 i = 0; i < tensor.NumElements(); ++i) {
out.push_back(tensor.flat<int32>()(i));
}
} else if (tensor.dtype() == DT_INT64) {
for (int64 i = 0; i < tensor.NumElements(); ++i) {
out.push_back(tensor.flat<int64>()(i));
}
} else {
// tensor must be either int32 or int64
DCHECK(false);
}
return out;
}
} // namespace
typedef Eigen::ThreadPoolDevice CPUDevice;
// A version of SharedValidation (slice_op.h) written for input that is in
// either Mkl layout or Tensorflow layout.
// A shared code to validate input shapes and check for identity, which is not dependent on the type of T.
// We do this to reduce code size by not duplicating all this for all T (float, double, int32, etc.)
static void ValidateMklInputs(OpKernelContext* context, bool* is_identity,
gtl::InlinedVector<int64, 4>* begin,
gtl::InlinedVector<int64, 4>* size) {
const int kInputTensorIndex = 0;
const int kInputBeginIndex = 1;
const int kInputSizeIndex = 2;
const Tensor& input = MklGetInput(context, kInputTensorIndex);
const Tensor& begin_tensor = MklGetInput(context, kInputBeginIndex);
const Tensor& size_tensor = MklGetInput(context, kInputSizeIndex);
MklDnnShape input_mkl_shape, begin_mkl_shape, size_mkl_shape;
GetMklShape(context, kInputTensorIndex, &input_mkl_shape);
GetMklShape(context, kInputBeginIndex, &begin_mkl_shape);
GetMklShape(context, kInputSizeIndex, &size_mkl_shape);
// Begin and size tensors cannot be in MklDnn layout.
DCHECK_EQ(begin_mkl_shape.IsMklTensor(), false);
DCHECK_EQ(size_mkl_shape.IsMklTensor(), false);
TensorShape input_tf_shape = input_mkl_shape.IsMklTensor()
? input_mkl_shape.GetTfShape()
: input.shape();
const int input_dims = input_tf_shape.dims();
OP_REQUIRES(
context, context->op_kernel().IsLegacyVector(begin_tensor.shape()) &&
context->op_kernel().IsLegacyVector(size_tensor.shape()) &&
begin_tensor.NumElements() == input_dims &&
size_tensor.NumElements() == input_dims,
errors::InvalidArgument(
"Expected begin and size arguments to be 1-D tensors of size ",
input_dims, ", but got shapes ", begin_tensor.shape().DebugString(),
" and ", size_tensor.shape().DebugString(), " instead."));
*begin = IntTensorToInt64Vec(begin_tensor);
*size = IntTensorToInt64Vec(size_tensor);
for (int i = 0; i < input_dims; ++i) {
if ((*size)[i] == -1) {
// A size[i] of -1 means "all elements from begin[i] to dim_size(i)".
(*size)[i] = input_tf_shape.dim_size(i) - (*begin)[i];
}
}
*is_identity = true;
for (int i = 0; i < input_dims; ++i) {
int64 b = (*begin)[i];
int64 s = (*size)[i];
if (input_tf_shape.dim_size(i) == 0) {
OP_REQUIRES(
context, b == 0 && s == 0,
errors::InvalidArgument("Expected begin[", i, "] == 0 (got ", b,
") and size[", i, "] == 0 ", "(got ", s,
") when ", "input.dim_size(", i, ") == 0"));
} else {
OP_REQUIRES(context, 0 <= b && b <= input_tf_shape.dim_size(i),
errors::InvalidArgument("Expected begin[", i, "] in [0, ",
input_tf_shape.dim_size(i),
"], but got ", b));
OP_REQUIRES(context, 0 <= s && b + s <= input_tf_shape.dim_size(i),
errors::InvalidArgument("Expected size[", i, "] in [0, ",
input_tf_shape.dim_size(i) - b,
"], but ", "got ", s));
}
const bool take_all = (b == 0) && (s == input_tf_shape.dim_size(i));
(*is_identity) &= take_all;
}
}
// A version of SharedSliceCommonCases function written for input tensor
// that may be in MklDnn layout or in Tensorflow layout.
template <typename T>
static void CheckCommonCasesForMklInputs(OpKernelContext* context,
gtl::InlinedVector<int64, 4>* begin,
gtl::InlinedVector<int64, 4>* size,
bool* done) {
bool is_identity = true;
*done = false;
ValidateMklInputs(context, &is_identity, begin, size);
if (!context->status().ok()) return;
const Tensor& input = MklGetInput(context, 0);
MklDnnShape input_mkl_shape;
GetMklShape(context, 0, &input_mkl_shape);
if (is_identity) {
VLOG(1) << "Slice identity";
context->set_output(0, input);
// Mkl metadata tensor in this case can just be forwarded from input to
// output.
AllocateOutputSetMklShape(context, 0, input_mkl_shape);
*done = true;
}
}
// MKL-DNN implementation of Slice
template <typename Device, typename T>
class MklDnnSliceOp : public OpKernel {
public:
explicit MklDnnSliceOp(OpKernelConstruction* context) : OpKernel(context) {}
~MklDnnSliceOp() {}
void Compute(OpKernelContext* context) override {
gtl::InlinedVector<int64, 4> begin;
gtl::InlinedVector<int64, 4> size;
bool done = false;
CheckCommonCasesForMklInputs<T>(context, &begin, &size, &done);
if (!context->status().ok() || done == true) return;
// Though MKL-DNN supports more than 8 dimension and
// less than 12 dimension tensor.
// But we are mimicking functionality of Eigen Slice op for CPU.
if (begin.size() >= 8) {
OP_REQUIRES(
context, false,
errors::Unimplemented("MklDnnSliceOp : Unhandled input dimensions"));
}
ComputeMklDnnSlice(context, begin, size);
}
private:
// Slice op implemented using MKL-DNN APIs.
void ComputeMklDnnSlice(OpKernelContext* context,
const gtl::InlinedVector<int64, 4>& begin,
const gtl::InlinedVector<int64, 4>& size) {
try {
// MKL-DNN API usage below is guided by description at:
// https://github.com/01org/mkl-dnn/issues/69
//
// Relevant part of the description is copied below:
//
// Let's say you want to copy a part of memory into another buffer (and
// probably change the format). Then your steps are:
//
// 1. create memory primitive descriptor in_mem_pd and memory primitive
// in_mem_p for the entire source data.
// 2. create view primitive descriptor in_submem_pd based on in_mem_pd,
// initial offsets, and sub-sizes
// 3. create memory primitive descriptor out_mem_pd and memory primitive
// out_mem_p for the output (the logical sizes should match sub-sizes
// used in step 2, but the format might be arbitrary)
// 4. create reorder primitive descriptor reorder_pd based on in_submem_pd
// and out_mem_pd
// 5. create reorder primitive itself based on reorder_pd, in_mem_p, and
// out_mem_p.
//
// Please notice that there is no view primitive. There is only view
// primitive descriptor. And the reorder uses source memory as input but
// traverses it according to a view in_submem_pd.
auto cpu_engine = engine(engine::cpu, 0);
MklDnnData<T> src(&cpu_engine);
MklDnnData<T> output(&cpu_engine);
// Populate offsets and sizes in memory::dims format based on vector.
memory::dims begin_dims = {};
begin_dims.resize(begin.size());
for (size_t i = 0; i < begin.size(); ++i) begin_dims[i] = begin[i];
memory::dims size_dims = {};
bool empty = false;
size_dims.resize(size.size());
for (size_t i = 0; i < size.size(); ++i) {
size_dims[i] = size[i];
if (size_dims[i] == 0) empty = true;
}
Tensor* output_tensor = nullptr;
MklDnnShape output_mkl_shape;
// If no dimension is selected in slice, the result should be empty.
// Just return an empty output tensor, and a dummy Mkl-shape tensor.
if (empty) { // for empty dims
auto shape_to = MklDnnDimsToTFShape(size_dims);
AllocateOutputSetMklShape(context, 0, &output_tensor, shape_to,
output_mkl_shape);
return;
}
// Step 1 (as per above description) - Create memory for user data.
// We use blocked format here to describe input tensor.
const Tensor& input_tensor = MklGetInput(context, 0);
MklDnnShape input_mkl_shape;
GetMklShape(context, 0, &input_mkl_shape);
if (input_mkl_shape.IsMklTensor()) {
auto input_mkl_format = input_mkl_shape.GetTfDataFormat();
auto input_tf_format = MklDnnDataFormatToTFDataFormat(input_mkl_format);
begin_dims = MklDnnDimsInNCHW(begin_dims, input_tf_format);
size_dims = MklDnnDimsInNCHW(size_dims, input_tf_format);
auto input_md = input_mkl_shape.GetMklLayout();
src.SetUsrMem(input_md, &input_tensor);
} else {
// Initialize input dimensions and strides to be used when input is not
// in MklDnn layout.
memory::dims input_dims, input_strides;
input_dims = TFShapeToMklDnnDims(input_tensor.shape());
input_strides = CalculateTFStrides(input_dims);
// Create input memory descriptor.
auto input_md =
MklDnnData<T>::CreateBlockedMemDesc(input_dims, input_strides);
src.SetUsrMem(input_md, &input_tensor);
}
// Step 2 - create view primitive descriptor
auto view_pd =
view::primitive_desc(src.GetUsrMemPrimDesc(), size_dims, begin_dims)
.dst_primitive_desc();
auto output_strides = CalculateTFStrides(size_dims);
auto output_md =
MklDnnData<T>::CreateBlockedMemDesc(size_dims, output_strides);
auto output_pd = memory::primitive_desc(output_md, cpu_engine);
// Step 3 - Create memory for output. If input is in MklDnn layout, then
// output is also in MklDnn layout. Otherwise, output is in Tensorflow
// layout.
AllocateOutputTensor(context, input_mkl_shape, &output_pd, size_dims,
&output_tensor, &output_mkl_shape);
DCHECK(output_tensor);
DCHECK_EQ(input_mkl_shape.IsMklTensor(), output_mkl_shape.IsMklTensor());
output.SetUsrMem(output_md, output_tensor);
std::vector<primitive> net;
// Step 4 - create reorder primitive desc between view_pd and output_pd.
auto reorder_pd =
reorder::primitive_desc(view_pd, output.GetUsrMemPrimDesc());
// Step 5 - create reorder primitive itself.
net.push_back(reorder(reorder_pd, *src.GetUsrMem(), *output.GetUsrMem()));
// Execute the reorder primitive.
stream(stream::kind::eager).submit(net).wait();
} catch (mkldnn::error& e) {
string error_msg = "Status: " + std::to_string(e.status) + ", message: " +
string(e.message) + ", in file " + string(__FILE__) +
":" + std::to_string(__LINE__);
OP_REQUIRES_OK(
context,
errors::Aborted("Operation received an exception:", error_msg));
}
}
private:
void AllocateOutputTensor(OpKernelContext* context,
const MklDnnShape& input_mkl_shape,
memory::primitive_desc* output_pd,
const memory::dims& output_dims,
Tensor** output_tensor,
MklDnnShape* output_mkl_shape) {
DCHECK(output_tensor);
DCHECK(output_mkl_shape);
TensorShape output_tf_shape;
if (input_mkl_shape.IsMklTensor()) {
// Since input tensor is in Mkl layout, output tensor will be in Mkl
// layout.
// Allocate shape of Mkl tensor.
output_mkl_shape->SetMklTensor(true);
output_mkl_shape->SetMklLayout(output_pd);
output_mkl_shape->SetElemType(MklDnnType<T>());
output_mkl_shape->SetTfLayout(input_mkl_shape.GetDimension(), output_dims,
input_mkl_shape.GetTfDataFormat());
output_tf_shape.AddDim((output_pd->get_size() / sizeof(T)) + 1);
} else {
// If input is not in Mkl layout, then output won't be in Mkl layout.
output_mkl_shape->SetMklTensor(false);
output_tf_shape = MklDnnDimsToTFShape(output_dims);
}
AllocateOutputSetMklShape(context, 0, output_tensor, output_tf_shape,
*output_mkl_shape);
}
};
// MKL-DNN Slice registration
#define REGISTER_MKL_SLICE(type) \
REGISTER_KERNEL_BUILDER(Name("_MklSlice") \
.Device(DEVICE_CPU) \
.TypeConstraint<type>("T") \
.HostMemory("begin") \
.HostMemory("size") \
.Label(mkl_op_registry::kMklOpLabel), \
MklDnnSliceOp<CPUDevice, type>);
TF_CALL_float(REGISTER_MKL_SLICE);
#undef REGISTER_MKL_SLICE
} // namespace tensorflow
#endif // INTEL_MKL_DNN
#endif // INTEL_MKL
Fix bug in MklSlice op when allocating output tensor. (#22914)
Wrongly "+1" for output shape, that will cause CopyFrom failure in MklToTf op because of tensor size and shape mismatch.
/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// See docs in ../ops/array_ops.cc.
#ifdef INTEL_MKL
#ifndef INTEL_MKL_ML_ONLY
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/framework/register_types.h"
#include "tensorflow/core/framework/tensor.h"
#include "tensorflow/core/kernels/ops_util.h"
#include "tensorflow/core/lib/core/status.h"
#include "tensorflow/core/lib/gtl/array_slice.h"
#include "tensorflow/core/platform/prefetch.h"
#include "third_party/eigen3/unsupported/Eigen/CXX11/Tensor"
#include "mkldnn.hpp"
#include "tensorflow/core/util/mkl_util.h"
using mkldnn::stream;
using mkldnn::view;
namespace tensorflow {
namespace {
gtl::InlinedVector<int64, 4> IntTensorToInt64Vec(const Tensor& tensor) {
gtl::InlinedVector<int64, 4> out;
if (tensor.dtype() == DT_INT32) {
for (int64 i = 0; i < tensor.NumElements(); ++i) {
out.push_back(tensor.flat<int32>()(i));
}
} else if (tensor.dtype() == DT_INT64) {
for (int64 i = 0; i < tensor.NumElements(); ++i) {
out.push_back(tensor.flat<int64>()(i));
}
} else {
// tensor must be either int32 or int64
DCHECK(false);
}
return out;
}
} // namespace
typedef Eigen::ThreadPoolDevice CPUDevice;
// A version of SharedValidation (slice_op.h) written for input that is in
// either Mkl layout or Tensorflow layout.
// A shared code to validate input shapes and check for identity, which is not dependent on the type of T.
// We do this to reduce code size by not duplicating all this for all T (float, double, int32, etc.)
static void ValidateMklInputs(OpKernelContext* context, bool* is_identity,
gtl::InlinedVector<int64, 4>* begin,
gtl::InlinedVector<int64, 4>* size) {
const int kInputTensorIndex = 0;
const int kInputBeginIndex = 1;
const int kInputSizeIndex = 2;
const Tensor& input = MklGetInput(context, kInputTensorIndex);
const Tensor& begin_tensor = MklGetInput(context, kInputBeginIndex);
const Tensor& size_tensor = MklGetInput(context, kInputSizeIndex);
MklDnnShape input_mkl_shape, begin_mkl_shape, size_mkl_shape;
GetMklShape(context, kInputTensorIndex, &input_mkl_shape);
GetMklShape(context, kInputBeginIndex, &begin_mkl_shape);
GetMklShape(context, kInputSizeIndex, &size_mkl_shape);
// Begin and size tensors cannot be in MklDnn layout.
DCHECK_EQ(begin_mkl_shape.IsMklTensor(), false);
DCHECK_EQ(size_mkl_shape.IsMklTensor(), false);
TensorShape input_tf_shape = input_mkl_shape.IsMklTensor()
? input_mkl_shape.GetTfShape()
: input.shape();
const int input_dims = input_tf_shape.dims();
OP_REQUIRES(
context, context->op_kernel().IsLegacyVector(begin_tensor.shape()) &&
context->op_kernel().IsLegacyVector(size_tensor.shape()) &&
begin_tensor.NumElements() == input_dims &&
size_tensor.NumElements() == input_dims,
errors::InvalidArgument(
"Expected begin and size arguments to be 1-D tensors of size ",
input_dims, ", but got shapes ", begin_tensor.shape().DebugString(),
" and ", size_tensor.shape().DebugString(), " instead."));
*begin = IntTensorToInt64Vec(begin_tensor);
*size = IntTensorToInt64Vec(size_tensor);
for (int i = 0; i < input_dims; ++i) {
if ((*size)[i] == -1) {
// A size[i] of -1 means "all elements from begin[i] to dim_size(i)".
(*size)[i] = input_tf_shape.dim_size(i) - (*begin)[i];
}
}
*is_identity = true;
for (int i = 0; i < input_dims; ++i) {
int64 b = (*begin)[i];
int64 s = (*size)[i];
if (input_tf_shape.dim_size(i) == 0) {
OP_REQUIRES(
context, b == 0 && s == 0,
errors::InvalidArgument("Expected begin[", i, "] == 0 (got ", b,
") and size[", i, "] == 0 ", "(got ", s,
") when ", "input.dim_size(", i, ") == 0"));
} else {
OP_REQUIRES(context, 0 <= b && b <= input_tf_shape.dim_size(i),
errors::InvalidArgument("Expected begin[", i, "] in [0, ",
input_tf_shape.dim_size(i),
"], but got ", b));
OP_REQUIRES(context, 0 <= s && b + s <= input_tf_shape.dim_size(i),
errors::InvalidArgument("Expected size[", i, "] in [0, ",
input_tf_shape.dim_size(i) - b,
"], but ", "got ", s));
}
const bool take_all = (b == 0) && (s == input_tf_shape.dim_size(i));
(*is_identity) &= take_all;
}
}
// A version of SharedSliceCommonCases function written for input tensor
// that may be in MklDnn layout or in Tensorflow layout.
template <typename T>
static void CheckCommonCasesForMklInputs(OpKernelContext* context,
gtl::InlinedVector<int64, 4>* begin,
gtl::InlinedVector<int64, 4>* size,
bool* done) {
bool is_identity = true;
*done = false;
ValidateMklInputs(context, &is_identity, begin, size);
if (!context->status().ok()) return;
const Tensor& input = MklGetInput(context, 0);
MklDnnShape input_mkl_shape;
GetMklShape(context, 0, &input_mkl_shape);
if (is_identity) {
VLOG(1) << "Slice identity";
context->set_output(0, input);
// Mkl metadata tensor in this case can just be forwarded from input to
// output.
AllocateOutputSetMklShape(context, 0, input_mkl_shape);
*done = true;
}
}
// MKL-DNN implementation of Slice
template <typename Device, typename T>
class MklDnnSliceOp : public OpKernel {
public:
explicit MklDnnSliceOp(OpKernelConstruction* context) : OpKernel(context) {}
~MklDnnSliceOp() {}
void Compute(OpKernelContext* context) override {
gtl::InlinedVector<int64, 4> begin;
gtl::InlinedVector<int64, 4> size;
bool done = false;
CheckCommonCasesForMklInputs<T>(context, &begin, &size, &done);
if (!context->status().ok() || done == true) return;
// Though MKL-DNN supports more than 8 dimension and
// less than 12 dimension tensor.
// But we are mimicking functionality of Eigen Slice op for CPU.
if (begin.size() >= 8) {
OP_REQUIRES(
context, false,
errors::Unimplemented("MklDnnSliceOp : Unhandled input dimensions"));
}
ComputeMklDnnSlice(context, begin, size);
}
private:
// Slice op implemented using MKL-DNN APIs.
void ComputeMklDnnSlice(OpKernelContext* context,
const gtl::InlinedVector<int64, 4>& begin,
const gtl::InlinedVector<int64, 4>& size) {
try {
// MKL-DNN API usage below is guided by description at:
// https://github.com/01org/mkl-dnn/issues/69
//
// Relevant part of the description is copied below:
//
// Let's say you want to copy a part of memory into another buffer (and
// probably change the format). Then your steps are:
//
// 1. create memory primitive descriptor in_mem_pd and memory primitive
// in_mem_p for the entire source data.
// 2. create view primitive descriptor in_submem_pd based on in_mem_pd,
// initial offsets, and sub-sizes
// 3. create memory primitive descriptor out_mem_pd and memory primitive
// out_mem_p for the output (the logical sizes should match sub-sizes
// used in step 2, but the format might be arbitrary)
// 4. create reorder primitive descriptor reorder_pd based on in_submem_pd
// and out_mem_pd
// 5. create reorder primitive itself based on reorder_pd, in_mem_p, and
// out_mem_p.
//
// Please notice that there is no view primitive. There is only view
// primitive descriptor. And the reorder uses source memory as input but
// traverses it according to a view in_submem_pd.
auto cpu_engine = engine(engine::cpu, 0);
MklDnnData<T> src(&cpu_engine);
MklDnnData<T> output(&cpu_engine);
// Populate offsets and sizes in memory::dims format based on vector.
memory::dims begin_dims = {};
begin_dims.resize(begin.size());
for (size_t i = 0; i < begin.size(); ++i) begin_dims[i] = begin[i];
memory::dims size_dims = {};
bool empty = false;
size_dims.resize(size.size());
for (size_t i = 0; i < size.size(); ++i) {
size_dims[i] = size[i];
if (size_dims[i] == 0) empty = true;
}
Tensor* output_tensor = nullptr;
MklDnnShape output_mkl_shape;
// If no dimension is selected in slice, the result should be empty.
// Just return an empty output tensor, and a dummy Mkl-shape tensor.
if (empty) { // for empty dims
auto shape_to = MklDnnDimsToTFShape(size_dims);
AllocateOutputSetMklShape(context, 0, &output_tensor, shape_to,
output_mkl_shape);
return;
}
// Step 1 (as per above description) - Create memory for user data.
// We use blocked format here to describe input tensor.
const Tensor& input_tensor = MklGetInput(context, 0);
MklDnnShape input_mkl_shape;
GetMklShape(context, 0, &input_mkl_shape);
if (input_mkl_shape.IsMklTensor()) {
auto input_mkl_format = input_mkl_shape.GetTfDataFormat();
auto input_tf_format = MklDnnDataFormatToTFDataFormat(input_mkl_format);
begin_dims = MklDnnDimsInNCHW(begin_dims, input_tf_format);
size_dims = MklDnnDimsInNCHW(size_dims, input_tf_format);
auto input_md = input_mkl_shape.GetMklLayout();
src.SetUsrMem(input_md, &input_tensor);
} else {
// Initialize input dimensions and strides to be used when input is not
// in MklDnn layout.
memory::dims input_dims, input_strides;
input_dims = TFShapeToMklDnnDims(input_tensor.shape());
input_strides = CalculateTFStrides(input_dims);
// Create input memory descriptor.
auto input_md =
MklDnnData<T>::CreateBlockedMemDesc(input_dims, input_strides);
src.SetUsrMem(input_md, &input_tensor);
}
// Step 2 - create view primitive descriptor
auto view_pd =
view::primitive_desc(src.GetUsrMemPrimDesc(), size_dims, begin_dims)
.dst_primitive_desc();
auto output_strides = CalculateTFStrides(size_dims);
auto output_md =
MklDnnData<T>::CreateBlockedMemDesc(size_dims, output_strides);
auto output_pd = memory::primitive_desc(output_md, cpu_engine);
// Step 3 - Create memory for output. If input is in MklDnn layout, then
// output is also in MklDnn layout. Otherwise, output is in Tensorflow
// layout.
AllocateOutputTensor(context, input_mkl_shape, &output_pd, size_dims,
&output_tensor, &output_mkl_shape);
DCHECK(output_tensor);
DCHECK_EQ(input_mkl_shape.IsMklTensor(), output_mkl_shape.IsMklTensor());
output.SetUsrMem(output_md, output_tensor);
std::vector<primitive> net;
// Step 4 - create reorder primitive desc between view_pd and output_pd.
auto reorder_pd =
reorder::primitive_desc(view_pd, output.GetUsrMemPrimDesc());
// Step 5 - create reorder primitive itself.
net.push_back(reorder(reorder_pd, *src.GetUsrMem(), *output.GetUsrMem()));
// Execute the reorder primitive.
stream(stream::kind::eager).submit(net).wait();
} catch (mkldnn::error& e) {
string error_msg = "Status: " + std::to_string(e.status) + ", message: " +
string(e.message) + ", in file " + string(__FILE__) +
":" + std::to_string(__LINE__);
OP_REQUIRES_OK(
context,
errors::Aborted("Operation received an exception:", error_msg));
}
}
private:
void AllocateOutputTensor(OpKernelContext* context,
const MklDnnShape& input_mkl_shape,
memory::primitive_desc* output_pd,
const memory::dims& output_dims,
Tensor** output_tensor,
MklDnnShape* output_mkl_shape) {
DCHECK(output_tensor);
DCHECK(output_mkl_shape);
TensorShape output_tf_shape;
if (input_mkl_shape.IsMklTensor()) {
// Since input tensor is in Mkl layout, output tensor will be in Mkl
// layout.
// Allocate shape of Mkl tensor.
output_mkl_shape->SetMklTensor(true);
output_mkl_shape->SetMklLayout(output_pd);
output_mkl_shape->SetElemType(MklDnnType<T>());
output_mkl_shape->SetTfLayout(input_mkl_shape.GetDimension(), output_dims,
input_mkl_shape.GetTfDataFormat());
output_tf_shape.AddDim(output_pd->get_size() / sizeof(T));
} else {
// If input is not in Mkl layout, then output won't be in Mkl layout.
output_mkl_shape->SetMklTensor(false);
output_tf_shape = MklDnnDimsToTFShape(output_dims);
}
AllocateOutputSetMklShape(context, 0, output_tensor, output_tf_shape,
*output_mkl_shape);
}
};
// MKL-DNN Slice registration
#define REGISTER_MKL_SLICE(type) \
REGISTER_KERNEL_BUILDER(Name("_MklSlice") \
.Device(DEVICE_CPU) \
.TypeConstraint<type>("T") \
.HostMemory("begin") \
.HostMemory("size") \
.Label(mkl_op_registry::kMklOpLabel), \
MklDnnSliceOp<CPUDevice, type>);
TF_CALL_float(REGISTER_MKL_SLICE);
#undef REGISTER_MKL_SLICE
} // namespace tensorflow
#endif // INTEL_MKL_DNN
#endif // INTEL_MKL
|
#include <QDebug>
#include <QList>
#include <QTimer>
#include <QtDBus>
#include <QtTest>
#include <TelepathyQt4/Connection>
#include <TelepathyQt4/Contact>
#include <TelepathyQt4/ContactManager>
#include <TelepathyQt4/PendingContacts>
#include <TelepathyQt4/PendingVoid>
#include <TelepathyQt4/PendingReady>
#include <TelepathyQt4/ReferencedHandles>
#include <TelepathyQt4/Debug>
#include <TelepathyQt4/Types>
#include <telepathy-glib/debug.h>
#include <tests/lib/glib/contacts-conn.h>
#include <tests/lib/glib/simple-conn.h>
#include <tests/lib/test.h>
using namespace Tp;
class TestContacts : public Test
{
Q_OBJECT
public:
TestContacts(QObject *parent = 0)
: Test(parent), mConnService(0)
{
}
protected Q_SLOTS:
void expectConnReady(Tp::Connection::Status, Tp::ConnectionStatusReason);
void expectConnInvalidated();
void expectPendingContactsFinished(Tp::PendingOperation *);
private Q_SLOTS:
void initTestCase();
void init();
void testSupport();
void testSelfContact();
void testForHandles();
void testForIdentifiers();
void testFeatures();
void testFeaturesNotRequested();
void testUpgrade();
void testSelfContactFallback();
void cleanup();
void cleanupTestCase();
private:
QString mConnName, mConnPath;
TpTestsContactsConnection *mConnService;
ConnectionPtr mConn;
QList<ContactPtr> mContacts;
Tp::UIntList mInvalidHandles;
};
void TestContacts::expectConnReady(Tp::Connection::Status newStatus,
Tp::ConnectionStatusReason newStatusReason)
{
switch (newStatus) {
case Connection::StatusDisconnected:
qWarning() << "Disconnected";
mLoop->exit(1);
break;
case Connection::StatusConnecting:
/* do nothing */
break;
case Connection::StatusConnected:
qDebug() << "Ready";
mLoop->exit(0);
break;
default:
qWarning().nospace() << "What sort of status is "
<< newStatus << "?!";
mLoop->exit(2);
break;
}
}
void TestContacts::expectConnInvalidated()
{
mLoop->exit(0);
}
void TestContacts::expectPendingContactsFinished(PendingOperation *op)
{
if (!op->isFinished()) {
qWarning() << "unfinished";
mLoop->exit(1);
return;
}
if (op->isError()) {
qWarning().nospace() << op->errorName()
<< ": " << op->errorMessage();
mLoop->exit(2);
return;
}
if (!op->isValid()) {
qWarning() << "inconsistent results";
mLoop->exit(3);
return;
}
qDebug() << "finished";
PendingContacts *pending = qobject_cast<PendingContacts *>(op);
mContacts = pending->contacts();
if (pending->isForHandles()) {
mInvalidHandles = pending->invalidHandles();
}
mLoop->exit(0);
}
void TestContacts::initTestCase()
{
initTestCaseImpl();
g_type_init();
g_set_prgname("contacts");
tp_debug_set_flags("all");
dbus_g_bus_get(DBUS_BUS_STARTER, 0);
gchar *name;
gchar *connPath;
GError *error = 0;
mConnService = TP_TESTS_CONTACTS_CONNECTION(g_object_new(
TP_TESTS_TYPE_CONTACTS_CONNECTION,
"account", "me@example.com",
"protocol", "simple",
NULL));
QVERIFY(mConnService != 0);
QVERIFY(tp_base_connection_register(TP_BASE_CONNECTION(mConnService), "contacts", &name,
&connPath, &error));
QVERIFY(error == 0);
QVERIFY(name != 0);
QVERIFY(connPath != 0);
mConnName = QLatin1String(name);
mConnPath = QLatin1String(connPath);
g_free(name);
g_free(connPath);
mConn = Connection::create(mConnName, mConnPath);
QCOMPARE(mConn->isReady(), false);
mConn->requestConnect();
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(mConn->becomeReady(features),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
if (mConn->status() != Connection::StatusConnected) {
QVERIFY(connect(mConn.data(),
SIGNAL(statusChanged(Tp::Connection::Status, Tp::ConnectionStatusReason)),
SLOT(expectConnReady(Tp::Connection::Status, Tp::ConnectionStatusReason))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(disconnect(mConn.data(),
SIGNAL(statusChanged(Tp::Connection::Status, Tp::ConnectionStatusReason)),
this,
SLOT(expectConnReady(Tp::Connection::Status, Tp::ConnectionStatusReason))));
QCOMPARE(mConn->status(), Connection::StatusConnected);
}
}
void TestContacts::init()
{
initImpl();
}
void TestContacts::testSupport()
{
QCOMPARE(mConn->contactManager()->connection(), mConn);
QVERIFY(!mConn->contactAttributeInterfaces().isEmpty());
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION)));
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION_INTERFACE_ALIASING)));
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION_INTERFACE_AVATARS)));
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE)));
QSet<Contact::Feature> supportedFeatures = mConn->contactManager()->supportedFeatures();
QVERIFY(!supportedFeatures.isEmpty());
QVERIFY(supportedFeatures.contains(Contact::FeatureAlias));
QVERIFY(supportedFeatures.contains(Contact::FeatureAvatarToken));
QVERIFY(supportedFeatures.contains(Contact::FeatureSimplePresence));
}
void TestContacts::testSelfContact()
{
ContactPtr selfContact = mConn->selfContact();
QVERIFY(selfContact != 0);
QCOMPARE(selfContact->handle()[0], mConn->selfHandle());
QCOMPARE(selfContact->id(), QString(QLatin1String("me@example.com")));
QVERIFY(connect(selfContact->manager()->upgradeContacts(
QList<ContactPtr>() << selfContact,
QSet<Contact::Feature>() << Contact::FeatureAlias
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(selfContact->alias(), QString(QLatin1String("me@example.com")));
QVERIFY(!selfContact->isAvatarTokenKnown());
QCOMPARE(selfContact->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(selfContact->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(selfContact->presenceMessage(), QString(QLatin1String("")));
}
void TestContacts::testForHandles()
{
Tp::UIntList handles;
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
// Set up a few valid handles
handles << tp_handle_ensure(serviceRepo, "alice", NULL, NULL);
QVERIFY(handles[0] != 0);
handles << tp_handle_ensure(serviceRepo, "bob", NULL, NULL);
QVERIFY(handles[1] != 0);
// Put one probably invalid one in between
handles << 31337;
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
// Then another valid one
handles << tp_handle_ensure(serviceRepo, "chris", NULL, NULL);
QVERIFY(handles[3] != 0);
// And yet another invalid one
handles << 12345;
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[4], NULL));
// Get contacts for the mixture of valid and invalid handles
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
// Test the closure accessors
QCOMPARE(pending->manager(), mConn->contactManager());
QCOMPARE(pending->features(), QSet<Contact::Feature>());
QVERIFY(pending->isForHandles());
QVERIFY(!pending->isForIdentifiers());
QVERIFY(!pending->isUpgrade());
QCOMPARE(pending->handles(), handles);
// Wait for the contacts to be built
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// There should be 3 resulting contacts and 2 handles found to be invalid
QCOMPARE(mContacts.size(), 3);
QCOMPARE(mInvalidHandles.size(), 2);
QCOMPARE(mInvalidHandles[0], handles[2]);
QCOMPARE(mInvalidHandles[1], handles[4]);
// Check the contact contents
for (int i = 0; i < 3; i++) {
QVERIFY(mContacts[i] != NULL);
QCOMPARE(mContacts[i]->manager(), mConn->contactManager());
QCOMPARE(mContacts[i]->requestedFeatures(), QSet<Contact::Feature>());
QCOMPARE(mContacts[i]->actualFeatures(), QSet<Contact::Feature>());
}
QCOMPARE(mContacts[0]->handle()[0], handles[0]);
QCOMPARE(mContacts[1]->handle()[0], handles[1]);
QCOMPARE(mContacts[2]->handle()[0], handles[3]);
QCOMPARE(mContacts[0]->id(), QString(QLatin1String("alice")));
QCOMPARE(mContacts[1]->id(), QString(QLatin1String("bob")));
QCOMPARE(mContacts[2]->id(), QString(QLatin1String("chris")));
// Save the contacts, and make a new request, replacing one of the invalid handles with a valid
// one
QList<ContactPtr> saveContacts = mContacts;
handles[2] = tp_handle_ensure(serviceRepo, "dora", NULL, NULL);
QVERIFY(handles[2] != 0);
pending = mConn->contactManager()->contactsForHandles(handles);
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that we got the correct number of contacts back
QCOMPARE(mContacts.size(), 4);
QCOMPARE(mInvalidHandles.size(), 1);
// Check that the contacts we already had were returned for the initial three
QCOMPARE(saveContacts[0], mContacts[0]);
QCOMPARE(saveContacts[1], mContacts[1]);
QCOMPARE(saveContacts[2], mContacts[3]);
// Check that the new contact is OK too
QCOMPARE(mContacts[2]->handle()[0], handles[2]);
QCOMPARE(mContacts[2]->id(), QString(QLatin1String("dora")));
// Make the contacts go out of scope, starting releasing their handles, and finish that
saveContacts.clear();
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
tp_handle_unref(serviceRepo, handles[3]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[3], NULL));
}
void TestContacts::testForIdentifiers()
{
QStringList validIDs = QStringList() << QLatin1String("Alice")
<< QLatin1String("Bob") << QLatin1String("Chris");
QStringList invalidIDs = QStringList() << QLatin1String("Not valid")
<< QLatin1String("Not valid either");
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
QStringList toCheck;
// Check that a request with just the invalid IDs fails
PendingContacts *fails = mConn->contactManager()->contactsForIdentifiers(invalidIDs);
QVERIFY(connect(fails,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
toCheck = fails->invalidIdentifiers().keys();
toCheck.sort();
invalidIDs.sort();
QCOMPARE(toCheck, invalidIDs);
// A request with both valid and invalid IDs should succeed
fails = mConn->contactManager()->contactsForIdentifiers(invalidIDs + validIDs + invalidIDs);
QVERIFY(connect(fails,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(fails->validIdentifiers(), validIDs);
toCheck = fails->invalidIdentifiers().keys();
toCheck.sort();
invalidIDs.sort();
QCOMPARE(toCheck, invalidIDs);
// Go on to the meat: valid IDs
PendingContacts *pending = mConn->contactManager()->contactsForIdentifiers(validIDs);
// Test the closure accessors
QCOMPARE(pending->manager(), mConn->contactManager());
QCOMPARE(pending->features(), QSet<Contact::Feature>());
QVERIFY(!pending->isForHandles());
QVERIFY(pending->isForIdentifiers());
QVERIFY(!pending->isUpgrade());
QCOMPARE(pending->identifiers(), validIDs);
// Finish it
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that there are 3 contacts consistent with the request
QCOMPARE(mContacts.size(), 3);
for (int i = 0; i < mContacts.size(); i++) {
QVERIFY(mContacts[i] != NULL);
QCOMPARE(mContacts[i]->manager(), mConn->contactManager());
QVERIFY(tp_handle_is_valid(serviceRepo, mContacts[i]->handle()[0], NULL));
QCOMPARE(mContacts[i]->requestedFeatures(), QSet<Contact::Feature>());
QCOMPARE(mContacts[i]->actualFeatures(), QSet<Contact::Feature>());
}
QCOMPARE(mContacts[0]->id(), QString(QLatin1String("alice")));
QCOMPARE(mContacts[1]->id(), QString(QLatin1String("bob")));
QCOMPARE(mContacts[2]->id(), QString(QLatin1String("chris")));
// Make the contacts go out of scope, starting releasing their handles, and finish that (but
// save their handles first)
Tp::UIntList saveHandles = Tp::UIntList() << mContacts[0]->handle()[0]
<< mContacts[1]->handle()[0]
<< mContacts[2]->handle()[0];
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Check that their handles are in fact released
foreach (uint handle, saveHandles) {
QVERIFY(!tp_handle_is_valid(serviceRepo, handle, NULL));
}
}
void TestContacts::testFeatures()
{
QStringList ids = QStringList() << QLatin1String("alice")
<< QLatin1String("bob") << QLatin1String("chris");
const char *initialAliases[] = {
"Alice in Wonderland",
"Bob the Builder",
"Chris Sawyer"
};
const char *latterAliases[] = {
"Alice Through the Looking Glass",
"Bob the Pensioner"
};
const char *initialTokens[] = {
"bbbbb",
"ccccc"
};
const char *latterTokens[] = {
"AAAA",
"BBBB"
};
static TpTestsContactsConnectionPresenceStatusIndex initialStatuses[] = {
TP_TESTS_CONTACTS_CONNECTION_STATUS_AVAILABLE,
TP_TESTS_CONTACTS_CONNECTION_STATUS_BUSY,
TP_TESTS_CONTACTS_CONNECTION_STATUS_AWAY
};
static TpTestsContactsConnectionPresenceStatusIndex latterStatuses[] = {
TP_TESTS_CONTACTS_CONNECTION_STATUS_AWAY,
TP_TESTS_CONTACTS_CONNECTION_STATUS_AVAILABLE,
};
const char *initialMessages[] = {
"",
"Fixing it",
"GON OUT BACKSON"
};
const char *latterMessages[] = {
"Having some carrots",
"Done building for life, yay",
};
QSet<Contact::Feature> features = QSet<Contact::Feature>()
<< Contact::FeatureAlias
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence;
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
// Get test handles
Tp::UIntList handles;
for (int i = 0; i < 3; i++) {
handles.push_back(tp_handle_ensure(serviceRepo, ids[i].toLatin1().constData(), NULL, NULL));
QVERIFY(handles[i] != 0);
}
// Set the initial attributes
tp_tests_contacts_connection_change_aliases(mConnService, 3, handles.toVector().constData(),
initialAliases);
tp_tests_contacts_connection_change_avatar_tokens(mConnService, 2, handles.toVector().constData() + 1,
initialTokens);
tp_tests_contacts_connection_change_presences(mConnService, 3, handles.toVector().constData(),
initialStatuses, initialMessages);
// Build contacts
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles, features);
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check the contact contents
QCOMPARE(mContacts.size(), 3);
for (int i = 0; i < 3; i++) {
QCOMPARE(mContacts[i]->handle()[0], handles[i]);
QCOMPARE(mContacts[i]->id(), ids[i]);
QVERIFY((features - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY((mContacts[i]->actualFeatures() - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAlias));
QCOMPARE(mContacts[i]->alias(), QString(QLatin1String(initialAliases[i])));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAvatarToken));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureSimplePresence));
QCOMPARE(mContacts[i]->presenceMessage(), QString(QLatin1String(initialMessages[i])));
}
// Check that there's no known avatar token for the first contact, but that there is for the
// two others
QVERIFY(!mContacts[0]->isAvatarTokenKnown());
QVERIFY(mContacts[1]->isAvatarTokenKnown());
QVERIFY(mContacts[2]->isAvatarTokenKnown());
QCOMPARE(mContacts[0]->avatarToken(), QString(QLatin1String("")));
QCOMPARE(mContacts[1]->avatarToken(), QString(QLatin1String(initialTokens[0])));
QCOMPARE(mContacts[2]->avatarToken(), QString(QLatin1String(initialTokens[1])));
QCOMPARE(mContacts[0]->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(mContacts[1]->presenceStatus(), QString(QLatin1String("busy")));
QCOMPARE(mContacts[2]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[0]->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(mContacts[1]->presenceType(), uint(Tp::ConnectionPresenceTypeBusy));
QCOMPARE(mContacts[2]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
// Change some of the contacts to a new set of attributes
tp_tests_contacts_connection_change_aliases(mConnService, 2, handles.toVector().constData(),
latterAliases);
tp_tests_contacts_connection_change_avatar_tokens(mConnService, 2, handles.toVector().constData(),
latterTokens);
tp_tests_contacts_connection_change_presences(mConnService, 2, handles.toVector().constData(),
latterStatuses, latterMessages);
mLoop->processEvents();
processDBusQueue(mConn.data());
// Check that the attributes were updated in the Contact objects
for (int i = 0; i < 3; i++) {
QCOMPARE(mContacts[i]->handle()[0], handles[i]);
QCOMPARE(mContacts[i]->id(), ids[i]);
QVERIFY((features - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY((mContacts[i]->actualFeatures() - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAlias));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAvatarToken));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureSimplePresence));
QVERIFY(mContacts[i]->isAvatarTokenKnown());
}
QCOMPARE(mContacts[0]->alias(), QString(QLatin1String(latterAliases[0])));
QCOMPARE(mContacts[1]->alias(), QString(QLatin1String(latterAliases[1])));
QCOMPARE(mContacts[2]->alias(), QString(QLatin1String(initialAliases[2])));
QCOMPARE(mContacts[0]->avatarToken(), QString(QLatin1String(latterTokens[0])));
QCOMPARE(mContacts[1]->avatarToken(), QString(QLatin1String(latterTokens[1])));
QCOMPARE(mContacts[2]->avatarToken(), QString(QLatin1String(initialTokens[1])));
QCOMPARE(mContacts[0]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[1]->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(mContacts[2]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[0]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
QCOMPARE(mContacts[1]->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(mContacts[2]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
QCOMPARE(mContacts[0]->presenceMessage(), QString(QLatin1String(latterMessages[0])));
QCOMPARE(mContacts[1]->presenceMessage(), QString(QLatin1String(latterMessages[1])));
QCOMPARE(mContacts[2]->presenceMessage(), QString(QLatin1String(initialMessages[2])));
// Make the contacts go out of scope, starting releasing their handles, and finish that
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
}
void TestContacts::testFeaturesNotRequested()
{
// Test ids and corresponding handles
QStringList ids = QStringList() << QLatin1String("alice")
<< QLatin1String("bob") << QLatin1String("chris");
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
Tp::UIntList handles;
for (int i = 0; i < 3; i++) {
handles.push_back(tp_handle_ensure(serviceRepo, ids[i].toLatin1().constData(), NULL, NULL));
QVERIFY(handles[i] != 0);
}
// Build contacts (note: no features)
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that the feature accessors return sensible fallback values (note: the warnings are
// intentional - however, I'm not quite sure if they should be just debug (like in tp-glib))
QCOMPARE(mContacts.size(), 3);
for (int i = 0; i < 3; i++) {
ContactPtr contact = mContacts[i];
QVERIFY(contact->requestedFeatures().isEmpty());
QVERIFY(contact->actualFeatures().isEmpty());
QCOMPARE(contact->alias(), contact->id());
QVERIFY(!contact->isAvatarTokenKnown());
QCOMPARE(contact->avatarToken(), QString(QLatin1String("")));
QCOMPARE(contact->presenceStatus(), QString(QLatin1String("unknown")));
QCOMPARE(contact->presenceType(), uint(Tp::ConnectionPresenceTypeUnknown));
QCOMPARE(contact->presenceMessage(), QString(QLatin1String("")));
}
// Make the contacts go out of scope, starting releasing their handles, and finish that
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
}
void TestContacts::testUpgrade()
{
QStringList ids = QStringList() << QLatin1String("alice")
<< QLatin1String("bob") << QLatin1String("chris");
const char *aliases[] = {
"Alice in Wonderland",
"Bob The Builder",
"Chris Sawyer"
};
const char *tokens[] = {
"aaaaa",
"bbbbb",
"ccccc"
};
static TpTestsContactsConnectionPresenceStatusIndex statuses[] = {
TP_TESTS_CONTACTS_CONNECTION_STATUS_AVAILABLE,
TP_TESTS_CONTACTS_CONNECTION_STATUS_BUSY,
TP_TESTS_CONTACTS_CONNECTION_STATUS_AWAY
};
const char *messages[] = {
"",
"Fixing it",
"GON OUT BACKSON"
};
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
Tp::UIntList handles;
for (int i = 0; i < 3; i++) {
handles.push_back(tp_handle_ensure(serviceRepo, ids[i].toLatin1().constData(), NULL, NULL));
QVERIFY(handles[i] != 0);
}
tp_tests_contacts_connection_change_aliases(mConnService, 3, handles.toVector().constData(), aliases);
tp_tests_contacts_connection_change_avatar_tokens(mConnService, 3, handles.toVector().constData(), tokens);
tp_tests_contacts_connection_change_presences(mConnService, 3, handles.toVector().constData(), statuses,
messages);
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
// Wait for the contacts to be built
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// There should be 3 resulting contacts - save them for future reference
QCOMPARE(mContacts.size(), 3);
QList<ContactPtr> saveContacts = mContacts;
// Upgrade them
QSet<Contact::Feature> features = QSet<Contact::Feature>()
<< Contact::FeatureAlias
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence;
pending = mConn->contactManager()->upgradeContacts(saveContacts, features);
// Test the closure accessors
QCOMPARE(pending->manager(), mConn->contactManager());
QCOMPARE(pending->features(), features);
QVERIFY(!pending->isForHandles());
QVERIFY(!pending->isForIdentifiers());
QVERIFY(pending->isUpgrade());
QCOMPARE(pending->contactsToUpgrade(), saveContacts);
// Wait for the contacts to be built
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that we got the correct contacts back
QCOMPARE(mContacts, saveContacts);
// Check the contact contents
for (int i = 0; i < 3; i++) {
QCOMPARE(mContacts[i]->handle()[0], handles[i]);
QCOMPARE(mContacts[i]->id(), ids[i]);
QVERIFY((features - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY((mContacts[i]->actualFeatures() - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAlias));
QCOMPARE(mContacts[i]->alias(), QString(QLatin1String(aliases[i])));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAvatarToken));
QVERIFY(mContacts[i]->isAvatarTokenKnown());
QCOMPARE(mContacts[i]->avatarToken(), QString(QLatin1String(tokens[i])));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureSimplePresence));
QCOMPARE(mContacts[i]->presenceMessage(), QString(QLatin1String(messages[i])));
}
QCOMPARE(mContacts[0]->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(mContacts[1]->presenceStatus(), QString(QLatin1String("busy")));
QCOMPARE(mContacts[2]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[0]->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(mContacts[1]->presenceType(), uint(Tp::ConnectionPresenceTypeBusy));
QCOMPARE(mContacts[2]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
// Make the contacts go out of scope, starting releasing their handles, and finish that
saveContacts.clear();
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
}
void TestContacts::testSelfContactFallback()
{
gchar *name;
gchar *connPath;
GError *error = 0;
TpTestsSimpleConnection *connService;
connService = TP_TESTS_SIMPLE_CONNECTION(g_object_new(
TP_TESTS_TYPE_SIMPLE_CONNECTION,
"account", "me@example.com",
"protocol", "simple",
NULL));
QVERIFY(connService != 0);
QVERIFY(tp_base_connection_register(TP_BASE_CONNECTION(connService), "simple", &name,
&connPath, &error));
QVERIFY(error == 0);
QVERIFY(name != 0);
QVERIFY(connPath != 0);
ConnectionPtr conn = Connection::create(QLatin1String(name), QLatin1String(connPath));
g_free(name);
g_free(connPath);
QCOMPARE(conn->isReady(), false);
conn->requestConnect();
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(conn->becomeReady(features),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(conn->isReady(features), true);
ContactPtr selfContact = conn->selfContact();
QVERIFY(selfContact != 0);
QCOMPARE(selfContact->handle()[0], conn->selfHandle());
QCOMPARE(selfContact->id(), QString(QLatin1String("me@example.com")));
QCOMPARE(selfContact->alias(), QString(QLatin1String("me@example.com")));
QVERIFY(!selfContact->isAvatarTokenKnown());
QCOMPARE(selfContact->presenceStatus(), QString(QLatin1String("unknown")));
}
void TestContacts::cleanup()
{
cleanupImpl();
}
void TestContacts::cleanupTestCase()
{
if (!mContacts.isEmpty()) {
mContacts.clear();
}
if (!mInvalidHandles.isEmpty()) {
mInvalidHandles.clear();
}
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
SIGNAL(invalidated(Tp::DBusProxy *, QString, QString)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
}
}
if (mConnService != 0) {
g_object_unref(mConnService);
mConnService = 0;
}
cleanupTestCaseImpl();
}
QTEST_MAIN(TestContacts)
#include "_gen/contacts.cpp.moc.hpp"
Plug memory leak in TestContacts::testSelfContactFallback()
#include <QDebug>
#include <QList>
#include <QTimer>
#include <QtDBus>
#include <QtTest>
#include <TelepathyQt4/Connection>
#include <TelepathyQt4/Contact>
#include <TelepathyQt4/ContactManager>
#include <TelepathyQt4/PendingContacts>
#include <TelepathyQt4/PendingVoid>
#include <TelepathyQt4/PendingReady>
#include <TelepathyQt4/ReferencedHandles>
#include <TelepathyQt4/Debug>
#include <TelepathyQt4/Types>
#include <telepathy-glib/debug.h>
#include <tests/lib/glib/contacts-conn.h>
#include <tests/lib/glib/simple-conn.h>
#include <tests/lib/test.h>
using namespace Tp;
class TestContacts : public Test
{
Q_OBJECT
public:
TestContacts(QObject *parent = 0)
: Test(parent), mConnService(0)
{
}
protected Q_SLOTS:
void expectConnReady(Tp::Connection::Status, Tp::ConnectionStatusReason);
void expectConnInvalidated();
void expectPendingContactsFinished(Tp::PendingOperation *);
private Q_SLOTS:
void initTestCase();
void init();
void testSupport();
void testSelfContact();
void testForHandles();
void testForIdentifiers();
void testFeatures();
void testFeaturesNotRequested();
void testUpgrade();
void testSelfContactFallback();
void cleanup();
void cleanupTestCase();
private:
QString mConnName, mConnPath;
TpTestsContactsConnection *mConnService;
ConnectionPtr mConn;
QList<ContactPtr> mContacts;
Tp::UIntList mInvalidHandles;
};
void TestContacts::expectConnReady(Tp::Connection::Status newStatus,
Tp::ConnectionStatusReason newStatusReason)
{
switch (newStatus) {
case Connection::StatusDisconnected:
qWarning() << "Disconnected";
mLoop->exit(1);
break;
case Connection::StatusConnecting:
/* do nothing */
break;
case Connection::StatusConnected:
qDebug() << "Ready";
mLoop->exit(0);
break;
default:
qWarning().nospace() << "What sort of status is "
<< newStatus << "?!";
mLoop->exit(2);
break;
}
}
void TestContacts::expectConnInvalidated()
{
mLoop->exit(0);
}
void TestContacts::expectPendingContactsFinished(PendingOperation *op)
{
if (!op->isFinished()) {
qWarning() << "unfinished";
mLoop->exit(1);
return;
}
if (op->isError()) {
qWarning().nospace() << op->errorName()
<< ": " << op->errorMessage();
mLoop->exit(2);
return;
}
if (!op->isValid()) {
qWarning() << "inconsistent results";
mLoop->exit(3);
return;
}
qDebug() << "finished";
PendingContacts *pending = qobject_cast<PendingContacts *>(op);
mContacts = pending->contacts();
if (pending->isForHandles()) {
mInvalidHandles = pending->invalidHandles();
}
mLoop->exit(0);
}
void TestContacts::initTestCase()
{
initTestCaseImpl();
g_type_init();
g_set_prgname("contacts");
tp_debug_set_flags("all");
dbus_g_bus_get(DBUS_BUS_STARTER, 0);
gchar *name;
gchar *connPath;
GError *error = 0;
mConnService = TP_TESTS_CONTACTS_CONNECTION(g_object_new(
TP_TESTS_TYPE_CONTACTS_CONNECTION,
"account", "me@example.com",
"protocol", "simple",
NULL));
QVERIFY(mConnService != 0);
QVERIFY(tp_base_connection_register(TP_BASE_CONNECTION(mConnService), "contacts", &name,
&connPath, &error));
QVERIFY(error == 0);
QVERIFY(name != 0);
QVERIFY(connPath != 0);
mConnName = QLatin1String(name);
mConnPath = QLatin1String(connPath);
g_free(name);
g_free(connPath);
mConn = Connection::create(mConnName, mConnPath);
QCOMPARE(mConn->isReady(), false);
mConn->requestConnect();
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(mConn->becomeReady(features),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
if (mConn->status() != Connection::StatusConnected) {
QVERIFY(connect(mConn.data(),
SIGNAL(statusChanged(Tp::Connection::Status, Tp::ConnectionStatusReason)),
SLOT(expectConnReady(Tp::Connection::Status, Tp::ConnectionStatusReason))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(disconnect(mConn.data(),
SIGNAL(statusChanged(Tp::Connection::Status, Tp::ConnectionStatusReason)),
this,
SLOT(expectConnReady(Tp::Connection::Status, Tp::ConnectionStatusReason))));
QCOMPARE(mConn->status(), Connection::StatusConnected);
}
}
void TestContacts::init()
{
initImpl();
}
void TestContacts::testSupport()
{
QCOMPARE(mConn->contactManager()->connection(), mConn);
QVERIFY(!mConn->contactAttributeInterfaces().isEmpty());
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION)));
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION_INTERFACE_ALIASING)));
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION_INTERFACE_AVATARS)));
QVERIFY(mConn->contactAttributeInterfaces().contains(
QLatin1String(TELEPATHY_INTERFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE)));
QSet<Contact::Feature> supportedFeatures = mConn->contactManager()->supportedFeatures();
QVERIFY(!supportedFeatures.isEmpty());
QVERIFY(supportedFeatures.contains(Contact::FeatureAlias));
QVERIFY(supportedFeatures.contains(Contact::FeatureAvatarToken));
QVERIFY(supportedFeatures.contains(Contact::FeatureSimplePresence));
}
void TestContacts::testSelfContact()
{
ContactPtr selfContact = mConn->selfContact();
QVERIFY(selfContact != 0);
QCOMPARE(selfContact->handle()[0], mConn->selfHandle());
QCOMPARE(selfContact->id(), QString(QLatin1String("me@example.com")));
QVERIFY(connect(selfContact->manager()->upgradeContacts(
QList<ContactPtr>() << selfContact,
QSet<Contact::Feature>() << Contact::FeatureAlias
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(selfContact->alias(), QString(QLatin1String("me@example.com")));
QVERIFY(!selfContact->isAvatarTokenKnown());
QCOMPARE(selfContact->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(selfContact->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(selfContact->presenceMessage(), QString(QLatin1String("")));
}
void TestContacts::testForHandles()
{
Tp::UIntList handles;
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
// Set up a few valid handles
handles << tp_handle_ensure(serviceRepo, "alice", NULL, NULL);
QVERIFY(handles[0] != 0);
handles << tp_handle_ensure(serviceRepo, "bob", NULL, NULL);
QVERIFY(handles[1] != 0);
// Put one probably invalid one in between
handles << 31337;
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
// Then another valid one
handles << tp_handle_ensure(serviceRepo, "chris", NULL, NULL);
QVERIFY(handles[3] != 0);
// And yet another invalid one
handles << 12345;
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[4], NULL));
// Get contacts for the mixture of valid and invalid handles
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
// Test the closure accessors
QCOMPARE(pending->manager(), mConn->contactManager());
QCOMPARE(pending->features(), QSet<Contact::Feature>());
QVERIFY(pending->isForHandles());
QVERIFY(!pending->isForIdentifiers());
QVERIFY(!pending->isUpgrade());
QCOMPARE(pending->handles(), handles);
// Wait for the contacts to be built
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// There should be 3 resulting contacts and 2 handles found to be invalid
QCOMPARE(mContacts.size(), 3);
QCOMPARE(mInvalidHandles.size(), 2);
QCOMPARE(mInvalidHandles[0], handles[2]);
QCOMPARE(mInvalidHandles[1], handles[4]);
// Check the contact contents
for (int i = 0; i < 3; i++) {
QVERIFY(mContacts[i] != NULL);
QCOMPARE(mContacts[i]->manager(), mConn->contactManager());
QCOMPARE(mContacts[i]->requestedFeatures(), QSet<Contact::Feature>());
QCOMPARE(mContacts[i]->actualFeatures(), QSet<Contact::Feature>());
}
QCOMPARE(mContacts[0]->handle()[0], handles[0]);
QCOMPARE(mContacts[1]->handle()[0], handles[1]);
QCOMPARE(mContacts[2]->handle()[0], handles[3]);
QCOMPARE(mContacts[0]->id(), QString(QLatin1String("alice")));
QCOMPARE(mContacts[1]->id(), QString(QLatin1String("bob")));
QCOMPARE(mContacts[2]->id(), QString(QLatin1String("chris")));
// Save the contacts, and make a new request, replacing one of the invalid handles with a valid
// one
QList<ContactPtr> saveContacts = mContacts;
handles[2] = tp_handle_ensure(serviceRepo, "dora", NULL, NULL);
QVERIFY(handles[2] != 0);
pending = mConn->contactManager()->contactsForHandles(handles);
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that we got the correct number of contacts back
QCOMPARE(mContacts.size(), 4);
QCOMPARE(mInvalidHandles.size(), 1);
// Check that the contacts we already had were returned for the initial three
QCOMPARE(saveContacts[0], mContacts[0]);
QCOMPARE(saveContacts[1], mContacts[1]);
QCOMPARE(saveContacts[2], mContacts[3]);
// Check that the new contact is OK too
QCOMPARE(mContacts[2]->handle()[0], handles[2]);
QCOMPARE(mContacts[2]->id(), QString(QLatin1String("dora")));
// Make the contacts go out of scope, starting releasing their handles, and finish that
saveContacts.clear();
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
tp_handle_unref(serviceRepo, handles[3]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[3], NULL));
}
void TestContacts::testForIdentifiers()
{
QStringList validIDs = QStringList() << QLatin1String("Alice")
<< QLatin1String("Bob") << QLatin1String("Chris");
QStringList invalidIDs = QStringList() << QLatin1String("Not valid")
<< QLatin1String("Not valid either");
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
QStringList toCheck;
// Check that a request with just the invalid IDs fails
PendingContacts *fails = mConn->contactManager()->contactsForIdentifiers(invalidIDs);
QVERIFY(connect(fails,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
toCheck = fails->invalidIdentifiers().keys();
toCheck.sort();
invalidIDs.sort();
QCOMPARE(toCheck, invalidIDs);
// A request with both valid and invalid IDs should succeed
fails = mConn->contactManager()->contactsForIdentifiers(invalidIDs + validIDs + invalidIDs);
QVERIFY(connect(fails,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(fails->validIdentifiers(), validIDs);
toCheck = fails->invalidIdentifiers().keys();
toCheck.sort();
invalidIDs.sort();
QCOMPARE(toCheck, invalidIDs);
// Go on to the meat: valid IDs
PendingContacts *pending = mConn->contactManager()->contactsForIdentifiers(validIDs);
// Test the closure accessors
QCOMPARE(pending->manager(), mConn->contactManager());
QCOMPARE(pending->features(), QSet<Contact::Feature>());
QVERIFY(!pending->isForHandles());
QVERIFY(pending->isForIdentifiers());
QVERIFY(!pending->isUpgrade());
QCOMPARE(pending->identifiers(), validIDs);
// Finish it
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that there are 3 contacts consistent with the request
QCOMPARE(mContacts.size(), 3);
for (int i = 0; i < mContacts.size(); i++) {
QVERIFY(mContacts[i] != NULL);
QCOMPARE(mContacts[i]->manager(), mConn->contactManager());
QVERIFY(tp_handle_is_valid(serviceRepo, mContacts[i]->handle()[0], NULL));
QCOMPARE(mContacts[i]->requestedFeatures(), QSet<Contact::Feature>());
QCOMPARE(mContacts[i]->actualFeatures(), QSet<Contact::Feature>());
}
QCOMPARE(mContacts[0]->id(), QString(QLatin1String("alice")));
QCOMPARE(mContacts[1]->id(), QString(QLatin1String("bob")));
QCOMPARE(mContacts[2]->id(), QString(QLatin1String("chris")));
// Make the contacts go out of scope, starting releasing their handles, and finish that (but
// save their handles first)
Tp::UIntList saveHandles = Tp::UIntList() << mContacts[0]->handle()[0]
<< mContacts[1]->handle()[0]
<< mContacts[2]->handle()[0];
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Check that their handles are in fact released
foreach (uint handle, saveHandles) {
QVERIFY(!tp_handle_is_valid(serviceRepo, handle, NULL));
}
}
void TestContacts::testFeatures()
{
QStringList ids = QStringList() << QLatin1String("alice")
<< QLatin1String("bob") << QLatin1String("chris");
const char *initialAliases[] = {
"Alice in Wonderland",
"Bob the Builder",
"Chris Sawyer"
};
const char *latterAliases[] = {
"Alice Through the Looking Glass",
"Bob the Pensioner"
};
const char *initialTokens[] = {
"bbbbb",
"ccccc"
};
const char *latterTokens[] = {
"AAAA",
"BBBB"
};
static TpTestsContactsConnectionPresenceStatusIndex initialStatuses[] = {
TP_TESTS_CONTACTS_CONNECTION_STATUS_AVAILABLE,
TP_TESTS_CONTACTS_CONNECTION_STATUS_BUSY,
TP_TESTS_CONTACTS_CONNECTION_STATUS_AWAY
};
static TpTestsContactsConnectionPresenceStatusIndex latterStatuses[] = {
TP_TESTS_CONTACTS_CONNECTION_STATUS_AWAY,
TP_TESTS_CONTACTS_CONNECTION_STATUS_AVAILABLE,
};
const char *initialMessages[] = {
"",
"Fixing it",
"GON OUT BACKSON"
};
const char *latterMessages[] = {
"Having some carrots",
"Done building for life, yay",
};
QSet<Contact::Feature> features = QSet<Contact::Feature>()
<< Contact::FeatureAlias
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence;
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
// Get test handles
Tp::UIntList handles;
for (int i = 0; i < 3; i++) {
handles.push_back(tp_handle_ensure(serviceRepo, ids[i].toLatin1().constData(), NULL, NULL));
QVERIFY(handles[i] != 0);
}
// Set the initial attributes
tp_tests_contacts_connection_change_aliases(mConnService, 3, handles.toVector().constData(),
initialAliases);
tp_tests_contacts_connection_change_avatar_tokens(mConnService, 2, handles.toVector().constData() + 1,
initialTokens);
tp_tests_contacts_connection_change_presences(mConnService, 3, handles.toVector().constData(),
initialStatuses, initialMessages);
// Build contacts
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles, features);
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check the contact contents
QCOMPARE(mContacts.size(), 3);
for (int i = 0; i < 3; i++) {
QCOMPARE(mContacts[i]->handle()[0], handles[i]);
QCOMPARE(mContacts[i]->id(), ids[i]);
QVERIFY((features - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY((mContacts[i]->actualFeatures() - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAlias));
QCOMPARE(mContacts[i]->alias(), QString(QLatin1String(initialAliases[i])));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAvatarToken));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureSimplePresence));
QCOMPARE(mContacts[i]->presenceMessage(), QString(QLatin1String(initialMessages[i])));
}
// Check that there's no known avatar token for the first contact, but that there is for the
// two others
QVERIFY(!mContacts[0]->isAvatarTokenKnown());
QVERIFY(mContacts[1]->isAvatarTokenKnown());
QVERIFY(mContacts[2]->isAvatarTokenKnown());
QCOMPARE(mContacts[0]->avatarToken(), QString(QLatin1String("")));
QCOMPARE(mContacts[1]->avatarToken(), QString(QLatin1String(initialTokens[0])));
QCOMPARE(mContacts[2]->avatarToken(), QString(QLatin1String(initialTokens[1])));
QCOMPARE(mContacts[0]->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(mContacts[1]->presenceStatus(), QString(QLatin1String("busy")));
QCOMPARE(mContacts[2]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[0]->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(mContacts[1]->presenceType(), uint(Tp::ConnectionPresenceTypeBusy));
QCOMPARE(mContacts[2]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
// Change some of the contacts to a new set of attributes
tp_tests_contacts_connection_change_aliases(mConnService, 2, handles.toVector().constData(),
latterAliases);
tp_tests_contacts_connection_change_avatar_tokens(mConnService, 2, handles.toVector().constData(),
latterTokens);
tp_tests_contacts_connection_change_presences(mConnService, 2, handles.toVector().constData(),
latterStatuses, latterMessages);
mLoop->processEvents();
processDBusQueue(mConn.data());
// Check that the attributes were updated in the Contact objects
for (int i = 0; i < 3; i++) {
QCOMPARE(mContacts[i]->handle()[0], handles[i]);
QCOMPARE(mContacts[i]->id(), ids[i]);
QVERIFY((features - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY((mContacts[i]->actualFeatures() - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAlias));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAvatarToken));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureSimplePresence));
QVERIFY(mContacts[i]->isAvatarTokenKnown());
}
QCOMPARE(mContacts[0]->alias(), QString(QLatin1String(latterAliases[0])));
QCOMPARE(mContacts[1]->alias(), QString(QLatin1String(latterAliases[1])));
QCOMPARE(mContacts[2]->alias(), QString(QLatin1String(initialAliases[2])));
QCOMPARE(mContacts[0]->avatarToken(), QString(QLatin1String(latterTokens[0])));
QCOMPARE(mContacts[1]->avatarToken(), QString(QLatin1String(latterTokens[1])));
QCOMPARE(mContacts[2]->avatarToken(), QString(QLatin1String(initialTokens[1])));
QCOMPARE(mContacts[0]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[1]->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(mContacts[2]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[0]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
QCOMPARE(mContacts[1]->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(mContacts[2]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
QCOMPARE(mContacts[0]->presenceMessage(), QString(QLatin1String(latterMessages[0])));
QCOMPARE(mContacts[1]->presenceMessage(), QString(QLatin1String(latterMessages[1])));
QCOMPARE(mContacts[2]->presenceMessage(), QString(QLatin1String(initialMessages[2])));
// Make the contacts go out of scope, starting releasing their handles, and finish that
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
}
void TestContacts::testFeaturesNotRequested()
{
// Test ids and corresponding handles
QStringList ids = QStringList() << QLatin1String("alice")
<< QLatin1String("bob") << QLatin1String("chris");
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
Tp::UIntList handles;
for (int i = 0; i < 3; i++) {
handles.push_back(tp_handle_ensure(serviceRepo, ids[i].toLatin1().constData(), NULL, NULL));
QVERIFY(handles[i] != 0);
}
// Build contacts (note: no features)
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that the feature accessors return sensible fallback values (note: the warnings are
// intentional - however, I'm not quite sure if they should be just debug (like in tp-glib))
QCOMPARE(mContacts.size(), 3);
for (int i = 0; i < 3; i++) {
ContactPtr contact = mContacts[i];
QVERIFY(contact->requestedFeatures().isEmpty());
QVERIFY(contact->actualFeatures().isEmpty());
QCOMPARE(contact->alias(), contact->id());
QVERIFY(!contact->isAvatarTokenKnown());
QCOMPARE(contact->avatarToken(), QString(QLatin1String("")));
QCOMPARE(contact->presenceStatus(), QString(QLatin1String("unknown")));
QCOMPARE(contact->presenceType(), uint(Tp::ConnectionPresenceTypeUnknown));
QCOMPARE(contact->presenceMessage(), QString(QLatin1String("")));
}
// Make the contacts go out of scope, starting releasing their handles, and finish that
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
}
void TestContacts::testUpgrade()
{
QStringList ids = QStringList() << QLatin1String("alice")
<< QLatin1String("bob") << QLatin1String("chris");
const char *aliases[] = {
"Alice in Wonderland",
"Bob The Builder",
"Chris Sawyer"
};
const char *tokens[] = {
"aaaaa",
"bbbbb",
"ccccc"
};
static TpTestsContactsConnectionPresenceStatusIndex statuses[] = {
TP_TESTS_CONTACTS_CONNECTION_STATUS_AVAILABLE,
TP_TESTS_CONTACTS_CONNECTION_STATUS_BUSY,
TP_TESTS_CONTACTS_CONNECTION_STATUS_AWAY
};
const char *messages[] = {
"",
"Fixing it",
"GON OUT BACKSON"
};
TpHandleRepoIface *serviceRepo =
tp_base_connection_get_handles(TP_BASE_CONNECTION(mConnService), TP_HANDLE_TYPE_CONTACT);
Tp::UIntList handles;
for (int i = 0; i < 3; i++) {
handles.push_back(tp_handle_ensure(serviceRepo, ids[i].toLatin1().constData(), NULL, NULL));
QVERIFY(handles[i] != 0);
}
tp_tests_contacts_connection_change_aliases(mConnService, 3, handles.toVector().constData(), aliases);
tp_tests_contacts_connection_change_avatar_tokens(mConnService, 3, handles.toVector().constData(), tokens);
tp_tests_contacts_connection_change_presences(mConnService, 3, handles.toVector().constData(), statuses,
messages);
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
// Wait for the contacts to be built
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// There should be 3 resulting contacts - save them for future reference
QCOMPARE(mContacts.size(), 3);
QList<ContactPtr> saveContacts = mContacts;
// Upgrade them
QSet<Contact::Feature> features = QSet<Contact::Feature>()
<< Contact::FeatureAlias
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence;
pending = mConn->contactManager()->upgradeContacts(saveContacts, features);
// Test the closure accessors
QCOMPARE(pending->manager(), mConn->contactManager());
QCOMPARE(pending->features(), features);
QVERIFY(!pending->isForHandles());
QVERIFY(!pending->isForIdentifiers());
QVERIFY(pending->isUpgrade());
QCOMPARE(pending->contactsToUpgrade(), saveContacts);
// Wait for the contacts to be built
QVERIFY(connect(pending,
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectPendingContactsFinished(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that we got the correct contacts back
QCOMPARE(mContacts, saveContacts);
// Check the contact contents
for (int i = 0; i < 3; i++) {
QCOMPARE(mContacts[i]->handle()[0], handles[i]);
QCOMPARE(mContacts[i]->id(), ids[i]);
QVERIFY((features - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY((mContacts[i]->actualFeatures() - mContacts[i]->requestedFeatures()).isEmpty());
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAlias));
QCOMPARE(mContacts[i]->alias(), QString(QLatin1String(aliases[i])));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureAvatarToken));
QVERIFY(mContacts[i]->isAvatarTokenKnown());
QCOMPARE(mContacts[i]->avatarToken(), QString(QLatin1String(tokens[i])));
QVERIFY(mContacts[i]->actualFeatures().contains(Contact::FeatureSimplePresence));
QCOMPARE(mContacts[i]->presenceMessage(), QString(QLatin1String(messages[i])));
}
QCOMPARE(mContacts[0]->presenceStatus(), QString(QLatin1String("available")));
QCOMPARE(mContacts[1]->presenceStatus(), QString(QLatin1String("busy")));
QCOMPARE(mContacts[2]->presenceStatus(), QString(QLatin1String("away")));
QCOMPARE(mContacts[0]->presenceType(), uint(Tp::ConnectionPresenceTypeAvailable));
QCOMPARE(mContacts[1]->presenceType(), uint(Tp::ConnectionPresenceTypeBusy));
QCOMPARE(mContacts[2]->presenceType(), uint(Tp::ConnectionPresenceTypeAway));
// Make the contacts go out of scope, starting releasing their handles, and finish that
saveContacts.clear();
mContacts.clear();
mLoop->processEvents();
processDBusQueue(mConn.data());
// Unref the handles we created service-side
tp_handle_unref(serviceRepo, handles[0]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[0], NULL));
tp_handle_unref(serviceRepo, handles[1]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[1], NULL));
tp_handle_unref(serviceRepo, handles[2]);
QVERIFY(!tp_handle_is_valid(serviceRepo, handles[2], NULL));
}
void TestContacts::testSelfContactFallback()
{
gchar *name;
gchar *connPath;
GError *error = 0;
TpTestsSimpleConnection *connService;
connService = TP_TESTS_SIMPLE_CONNECTION(g_object_new(
TP_TESTS_TYPE_SIMPLE_CONNECTION,
"account", "me@example.com",
"protocol", "simple",
NULL));
QVERIFY(connService != 0);
QVERIFY(tp_base_connection_register(TP_BASE_CONNECTION(connService), "simple", &name,
&connPath, &error));
QVERIFY(error == 0);
QVERIFY(name != 0);
QVERIFY(connPath != 0);
ConnectionPtr conn = Connection::create(QLatin1String(name), QLatin1String(connPath));
g_free(name);
g_free(connPath);
QCOMPARE(conn->isReady(), false);
conn->requestConnect();
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(conn->becomeReady(features),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(conn->isReady(features), true);
ContactPtr selfContact = conn->selfContact();
QVERIFY(selfContact != 0);
QCOMPARE(selfContact->handle()[0], conn->selfHandle());
QCOMPARE(selfContact->id(), QString(QLatin1String("me@example.com")));
QCOMPARE(selfContact->alias(), QString(QLatin1String("me@example.com")));
QVERIFY(!selfContact->isAvatarTokenKnown());
QCOMPARE(selfContact->presenceStatus(), QString(QLatin1String("unknown")));
tp_tests_simple_connection_inject_disconnect(connService);
if (conn->isValid()) {
QVERIFY(connect(conn.data(),
SIGNAL(invalidated(Tp::DBusProxy *,
const QString &, const QString &)),
mLoop,
SLOT(quit())));
QCOMPARE(mLoop->exec(), 0);
}
g_object_unref(connService);
}
void TestContacts::cleanup()
{
cleanupImpl();
}
void TestContacts::cleanupTestCase()
{
if (!mContacts.isEmpty()) {
mContacts.clear();
}
if (!mInvalidHandles.isEmpty()) {
mInvalidHandles.clear();
}
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
SIGNAL(finished(Tp::PendingOperation*)),
SLOT(expectSuccessfulCall(Tp::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
SIGNAL(invalidated(Tp::DBusProxy *, QString, QString)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
}
}
if (mConnService != 0) {
g_object_unref(mConnService);
mConnService = 0;
}
cleanupTestCaseImpl();
}
QTEST_MAIN(TestContacts)
#include "_gen/contacts.cpp.moc.hpp"
|
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/lite/delegates/gpu/gl/api.h"
#include <algorithm>
#include <cstdint>
#include <deque>
#include <mutex> // NOLINT
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
#include "tensorflow/lite/delegates/gpu/common/model.h"
#include "tensorflow/lite/delegates/gpu/common/status.h"
#include "tensorflow/lite/delegates/gpu/common/types.h"
#include "tensorflow/lite/delegates/gpu/common/util.h"
#include "tensorflow/lite/delegates/gpu/gl/compiler.h"
#include "tensorflow/lite/delegates/gpu/gl/gl_call.h"
#include "tensorflow/lite/delegates/gpu/gl/gpu_info.h"
#include "tensorflow/lite/delegates/gpu/gl/object.h"
#include "tensorflow/lite/delegates/gpu/gl/portable_gl31.h"
#include "tensorflow/lite/delegates/gpu/gl/runtime.h"
#ifndef TFLITE_GPU_BINARY_RELEASE
#include "tensorflow/lite/delegates/gpu/gl/serialization.h"
#endif // TFLITE_GPU_BINARY_RELEASE
namespace tflite {
namespace gpu {
namespace gl {
namespace {
using ObjectsSizes = std::unordered_map<ValueId, size_t>;
enum class InferenceContextState {
NOT_STARTED,
IN_PROGRESS,
};
class InferenceContextImpl : public InferenceContext {
public:
explicit InferenceContextImpl(std::unique_ptr<Runtime> runtime)
: runtime_(std::move(runtime)) {}
Status Execute() final {
std::lock_guard<std::mutex> lock(guard_);
if (state_ != InferenceContextState::NOT_STARTED) {
return FailedPreconditionError("InferenceContext is not reset");
}
state_ = InferenceContextState::IN_PROGRESS;
return runtime_->Execute();
}
Status Reset() final {
std::lock_guard<std::mutex> lock(guard_);
// TODO(akulik): should Reset not return Status?
state_ = InferenceContextState::NOT_STARTED;
return OkStatus();
}
RuntimeStats stats() const final { return runtime_->stats(); }
private:
std::unique_ptr<Runtime> runtime_;
mutable std::mutex guard_;
InferenceContextState state_ = InferenceContextState::NOT_STARTED;
};
class InferenceContextWithBatchImpl : public InferenceContext {
public:
InferenceContextWithBatchImpl(const ObjectsSizes& sizes,
const ObjectManager* objects,
std::unique_ptr<ObjectManager> refs,
std::unique_ptr<Runtime> runtime)
: sizes_(sizes),
objects_(objects),
refs_(std::move(refs)),
runtime_(std::move(runtime)) {}
Status Execute() final {
std::lock_guard<std::mutex> lock(guard_);
if (state_ != InferenceContextState::NOT_STARTED) {
return FailedPreconditionError("InferenceContext is not reset");
}
state_ = InferenceContextState::IN_PROGRESS;
// Calculate expected number of batches and check that all external objects
// match that number.
int num_batches = 0;
for (const auto& s : sizes_) {
const ValueId id = s.first;
const size_t byte_size = s.second;
auto buffer = objects_->FindBuffer(id);
if (!buffer) continue;
if (buffer->bytes_size() % byte_size) {
return InvalidArgumentError(absl::StrCat(
"Object ", id, " does not match expected byte size: ", byte_size));
}
const size_t b = buffer->bytes_size() / byte_size;
if (num_batches == 0) {
num_batches = b;
} else if (num_batches != b) {
return InvalidArgumentError(absl::StrCat(
"Object ", id, " size does not match expected batch size: ", b,
" vs ", num_batches));
}
}
for (size_t b = 0; b < num_batches; ++b) {
// slice external objects by batch.
for (const auto& s : sizes_) {
const ValueId id = s.first;
const size_t byte_size = s.second;
auto buffer = objects_->FindBuffer(id);
if (buffer) {
auto ref = refs_->FindBuffer(id);
if (!ref) {
return InvalidArgumentError(
absl::StrCat("Reference to ", id, " is not found"));
}
RETURN_IF_ERROR(buffer->MakeView(b * byte_size, byte_size, ref));
}
}
RETURN_IF_ERROR(runtime_->Execute());
}
return OkStatus();
}
Status Reset() final {
std::lock_guard<std::mutex> lock(guard_);
state_ = InferenceContextState::NOT_STARTED;
// TODO(akulik): should Reset not return Status?
return OkStatus();
}
RuntimeStats stats() const final { return runtime_->stats(); }
private:
const ObjectsSizes sizes_;
const ObjectManager* objects_;
// view over external objects provided by a user.
std::unique_ptr<ObjectManager> refs_;
std::unique_ptr<Runtime> runtime_;
mutable std::mutex guard_;
InferenceContextState state_ = InferenceContextState::NOT_STARTED;
};
struct ProgramParameters {
// A list of uniform parameters to be set.
std::vector<UniformParameter> parameters;
// A list of objects to bind to opengl program.
std::vector<Object> objects;
uint3 workgroup_size;
uint3 num_workgroups;
size_t shader_idx;
};
std::string GetShaderHeader(uint3 localsize) {
return absl::StrCat("#version 310 es\nlayout(local_size_x = ", localsize.x,
", local_size_y = ", localsize.y,
", local_size_z = ", localsize.z, ") in;\n");
}
class CompiledModelImpl
#ifndef TFLITE_GPU_BINARY_RELEASE
: public CompiledModel,
public DeserializationHandler {
#else
: public CompiledModel {
#endif // TFLITE_GPU_BINARY_RELEASE
public:
explicit CompiledModelImpl(const GpuInfo& gpu_info) : gpu_info_(gpu_info) {}
// Called while compiling shaders from scratch
Status Add(const WorkgroupsCalculator& workgroup_calculator,
ShaderCode code) {
// Calculate workgroup size.
uint3 workgroup_size = workgroup_calculator.Calculate(code);
uint3 num_workgroups = IntegralDivideRoundUp(code.workload, workgroup_size);
for (const auto& object : code.objects) {
if (IsRef(object)) {
object_sizes_[GetRef(object)] = ByteSizeOf(object);
}
}
// Store full shader and compile it if necessary.
size_t shader_idx;
RETURN_IF_ERROR(
AddFullShader(code.source_code, workgroup_size, &shader_idx));
programs_.push_back({
std::move(code.parameters),
std::move(code.objects),
workgroup_size,
num_workgroups,
shader_idx,
});
return OkStatus();
}
// Store full shader and compile it if necessary.
// Returns full_shader_index
Status AddFullShader(const std::string& partial_shader,
const uint3& workgroup_size, size_t* size) {
std::string shader_src = GetShaderHeader(workgroup_size) + partial_shader;
auto it = shader_to_index_.find(shader_src);
if (it == shader_to_index_.end()) {
GlShader shader;
RETURN_IF_ERROR(
GlShader::CompileShader(GL_COMPUTE_SHADER, shader_src, &shader));
shaders_.push_back(std::move(shader));
shader_to_index_.insert({shader_src, shader_to_index_.size()});
*size = shader_to_index_.size() - 1;
} else {
*size = it->second;
}
return OkStatus();
}
Status NewRun(
const RuntimeOptions& options, const ObjectManager* objects,
CommandQueue* command_queue,
std::unique_ptr<InferenceContext>* inference_context) const final {
std::unique_ptr<ObjectManager> refs;
if (dynamic_batch_) {
// Runtime is using objects from refs that will point to provided objects.
// At this point just create 0 batch slice references.
refs = absl::make_unique<ObjectManager>();
for (const auto& s : object_sizes_) {
auto buffer = objects->FindBuffer(s.first);
if (!buffer) continue;
GlBuffer ref;
RETURN_IF_ERROR(buffer->MakeView(0, s.second, &ref));
RETURN_IF_ERROR(refs->RegisterBuffer(s.first, std::move(ref)));
}
}
auto runtime = absl::make_unique<Runtime>(options, gpu_info_, command_queue,
refs ? refs.get() : objects);
for (auto& c : programs_) {
RETURN_IF_ERROR(runtime->AddProgram(shaders_[c.shader_idx], c.parameters,
c.objects, c.num_workgroups));
}
RETURN_IF_ERROR(runtime->PrepareForExecution());
if (dynamic_batch_) {
*inference_context = absl::make_unique<InferenceContextWithBatchImpl>(
object_sizes_, objects, std::move(refs), std::move(runtime));
} else {
*inference_context =
absl::make_unique<InferenceContextImpl>(std::move(runtime));
}
return OkStatus();
}
#ifndef TFLITE_GPU_BINARY_RELEASE
// Called on deserialization
Status OnProgram(const std::vector<UniformParameter>& parameters,
const std::vector<Object>& objects,
const uint3& workgroup_size, const uint3& num_workgroups,
size_t partial_shader_index) final {
for (auto& object : objects) {
if (IsRef(object)) {
object_sizes_[GetRef(object)] = ByteSizeOf(object);
}
}
size_t shader_idx;
RETURN_IF_ERROR(AddFullShader(partial_shaders_[partial_shader_index],
workgroup_size, &shader_idx));
programs_.push_back({
parameters,
objects,
workgroup_size,
num_workgroups,
shader_idx,
});
return OkStatus();
}
Status Serialize(
std::vector<uint8_t>* serialized_compiled_model) const final {
SerializedCompiledModelBuilder builder;
// sort shaders first. They need to be serialized in order.
std::vector<std::string> full_shaders(shaders_.size());
for (const auto& shader : shader_to_index_) {
full_shaders[shader.second] = shader.first;
}
std::unordered_map<std::string, size_t> partial_shader_to_index;
std::vector<std::string> partial_shaders;
for (const auto& program : programs_) {
// Remove a header from a shader.
std::string shader_without_header = full_shaders[program.shader_idx];
shader_without_header.erase(0, shader_without_header.find("in;") + 3);
// Insert shader into partial shaders array.
auto it = partial_shader_to_index.find(shader_without_header);
size_t shader_idx;
if (it == partial_shader_to_index.end()) {
shader_idx = partial_shaders.size();
partial_shaders.push_back(shader_without_header);
builder.AddShader(shader_without_header);
partial_shader_to_index.insert({shader_without_header, shader_idx});
} else {
shader_idx = it->second;
}
builder.AddProgram(program.parameters, program.objects,
program.workgroup_size, program.num_workgroups,
shader_idx);
}
CompiledModelOptions options;
options.dynamic_batch = dynamic_batch_;
auto data = builder.Finalize(options);
serialized_compiled_model->insert(serialized_compiled_model->end(),
data.begin(), data.end());
return OkStatus();
}
Status OnShader(absl::Span<const char> shader_src) final {
std::string source(shader_src.data(), shader_src.size());
partial_shaders_.push_back(source);
return OkStatus();
}
void OnOptions(const CompiledModelOptions& options) final {
dynamic_batch_ = options.dynamic_batch;
}
#endif // TFLITE_GPU_BINARY_RELEASE
CompilerStats stats() const final { return stats_; }
void set_dynamic_batch(bool dynamic_batch) { dynamic_batch_ = dynamic_batch; }
private:
const GpuInfo gpu_info_;
bool dynamic_batch_ = false;
std::vector<std::string> partial_shaders_;
std::vector<GlShader> shaders_;
// Shaders are serialized in order of their indices.
std::unordered_map<std::string, size_t> shader_to_index_;
std::deque<ProgramParameters> programs_;
std::unordered_map<ValueId, size_t> object_sizes_;
CompilerStats stats_;
};
// @return true if all tensors have same batch value.
bool IsBatchMatchesForAllValues(const GraphFloat32& model) {
const int32_t b = model.values()[0]->tensor.shape.b;
for (auto value : model.values()) {
if (value->tensor.shape.b != b) {
return false;
}
}
return true;
}
} // namespace
Status Compile(const CompilationOptions& options, const GraphFloat32& model,
const std::unordered_set<int>& tflite_graph_io,
const NodeShader& node_shader,
const WorkgroupsCalculator& workgroup_calculator,
std::unique_ptr<CompiledModel>* compiled_model) {
if (!IsBatchMatchesForAllValues(model)) {
return InvalidArgumentError("Only identical batch dimension is supported");
}
GpuInfo gpu_info;
RETURN_IF_ERROR(RequestGpuInfo(&gpu_info));
auto compiled_model_impl = absl::make_unique<CompiledModelImpl>(gpu_info);
compiled_model_impl->set_dynamic_batch(options.dynamic_batch);
auto compiler = NewCompiler(&node_shader, &gpu_info, options);
RETURN_IF_ERROR(
compiler->Compile(model, tflite_graph_io, [&](ShaderCode code) -> Status {
return compiled_model_impl->Add(workgroup_calculator, std::move(code));
}));
*compiled_model = std::move(compiled_model_impl);
return OkStatus();
}
#ifndef TFLITE_GPU_BINARY_RELEASE
Status ReadSerializedModel(const std::vector<uint8_t>& serialized_model,
std::unique_ptr<CompiledModel>* compiled_model) {
GpuInfo gpu_info;
RETURN_IF_ERROR(RequestGpuInfo(&gpu_info));
auto compiled_model_impl = absl::make_unique<CompiledModelImpl>(gpu_info);
RETURN_IF_ERROR(DeserializeCompiledModel(
absl::MakeConstSpan(serialized_model), compiled_model_impl.get()));
*compiled_model = std::move(compiled_model_impl);
return OkStatus();
}
#endif // TFLITE_GPU_BINARY_RELEASE
} // namespace gl
} // namespace gpu
} // namespace tflite
Explicitly require OpenGL ES 3.1 to use OpenGL inference.
PiperOrigin-RevId: 253908072
/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/lite/delegates/gpu/gl/api.h"
#include <algorithm>
#include <cstdint>
#include <deque>
#include <mutex> // NOLINT
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "absl/memory/memory.h"
#include "absl/strings/str_cat.h"
#include "tensorflow/lite/delegates/gpu/common/model.h"
#include "tensorflow/lite/delegates/gpu/common/status.h"
#include "tensorflow/lite/delegates/gpu/common/types.h"
#include "tensorflow/lite/delegates/gpu/common/util.h"
#include "tensorflow/lite/delegates/gpu/gl/compiler.h"
#include "tensorflow/lite/delegates/gpu/gl/gl_call.h"
#include "tensorflow/lite/delegates/gpu/gl/gpu_info.h"
#include "tensorflow/lite/delegates/gpu/gl/object.h"
#include "tensorflow/lite/delegates/gpu/gl/portable_gl31.h"
#include "tensorflow/lite/delegates/gpu/gl/runtime.h"
#ifndef TFLITE_GPU_BINARY_RELEASE
#include "tensorflow/lite/delegates/gpu/gl/serialization.h"
#endif // TFLITE_GPU_BINARY_RELEASE
namespace tflite {
namespace gpu {
namespace gl {
namespace {
using ObjectsSizes = std::unordered_map<ValueId, size_t>;
enum class InferenceContextState {
NOT_STARTED,
IN_PROGRESS,
};
class InferenceContextImpl : public InferenceContext {
public:
explicit InferenceContextImpl(std::unique_ptr<Runtime> runtime)
: runtime_(std::move(runtime)) {}
Status Execute() final {
std::lock_guard<std::mutex> lock(guard_);
if (state_ != InferenceContextState::NOT_STARTED) {
return FailedPreconditionError("InferenceContext is not reset");
}
state_ = InferenceContextState::IN_PROGRESS;
return runtime_->Execute();
}
Status Reset() final {
std::lock_guard<std::mutex> lock(guard_);
// TODO(akulik): should Reset not return Status?
state_ = InferenceContextState::NOT_STARTED;
return OkStatus();
}
RuntimeStats stats() const final { return runtime_->stats(); }
private:
std::unique_ptr<Runtime> runtime_;
mutable std::mutex guard_;
InferenceContextState state_ = InferenceContextState::NOT_STARTED;
};
class InferenceContextWithBatchImpl : public InferenceContext {
public:
InferenceContextWithBatchImpl(const ObjectsSizes& sizes,
const ObjectManager* objects,
std::unique_ptr<ObjectManager> refs,
std::unique_ptr<Runtime> runtime)
: sizes_(sizes),
objects_(objects),
refs_(std::move(refs)),
runtime_(std::move(runtime)) {}
Status Execute() final {
std::lock_guard<std::mutex> lock(guard_);
if (state_ != InferenceContextState::NOT_STARTED) {
return FailedPreconditionError("InferenceContext is not reset");
}
state_ = InferenceContextState::IN_PROGRESS;
// Calculate expected number of batches and check that all external objects
// match that number.
int num_batches = 0;
for (const auto& s : sizes_) {
const ValueId id = s.first;
const size_t byte_size = s.second;
auto buffer = objects_->FindBuffer(id);
if (!buffer) continue;
if (buffer->bytes_size() % byte_size) {
return InvalidArgumentError(absl::StrCat(
"Object ", id, " does not match expected byte size: ", byte_size));
}
const size_t b = buffer->bytes_size() / byte_size;
if (num_batches == 0) {
num_batches = b;
} else if (num_batches != b) {
return InvalidArgumentError(absl::StrCat(
"Object ", id, " size does not match expected batch size: ", b,
" vs ", num_batches));
}
}
for (size_t b = 0; b < num_batches; ++b) {
// slice external objects by batch.
for (const auto& s : sizes_) {
const ValueId id = s.first;
const size_t byte_size = s.second;
auto buffer = objects_->FindBuffer(id);
if (buffer) {
auto ref = refs_->FindBuffer(id);
if (!ref) {
return InvalidArgumentError(
absl::StrCat("Reference to ", id, " is not found"));
}
RETURN_IF_ERROR(buffer->MakeView(b * byte_size, byte_size, ref));
}
}
RETURN_IF_ERROR(runtime_->Execute());
}
return OkStatus();
}
Status Reset() final {
std::lock_guard<std::mutex> lock(guard_);
state_ = InferenceContextState::NOT_STARTED;
// TODO(akulik): should Reset not return Status?
return OkStatus();
}
RuntimeStats stats() const final { return runtime_->stats(); }
private:
const ObjectsSizes sizes_;
const ObjectManager* objects_;
// view over external objects provided by a user.
std::unique_ptr<ObjectManager> refs_;
std::unique_ptr<Runtime> runtime_;
mutable std::mutex guard_;
InferenceContextState state_ = InferenceContextState::NOT_STARTED;
};
struct ProgramParameters {
// A list of uniform parameters to be set.
std::vector<UniformParameter> parameters;
// A list of objects to bind to opengl program.
std::vector<Object> objects;
uint3 workgroup_size;
uint3 num_workgroups;
size_t shader_idx;
};
std::string GetShaderHeader(uint3 localsize) {
return absl::StrCat("#version 310 es\nlayout(local_size_x = ", localsize.x,
", local_size_y = ", localsize.y,
", local_size_z = ", localsize.z, ") in;\n");
}
class CompiledModelImpl
#ifndef TFLITE_GPU_BINARY_RELEASE
: public CompiledModel,
public DeserializationHandler {
#else
: public CompiledModel {
#endif // TFLITE_GPU_BINARY_RELEASE
public:
explicit CompiledModelImpl(const GpuInfo& gpu_info) : gpu_info_(gpu_info) {}
// Called while compiling shaders from scratch
Status Add(const WorkgroupsCalculator& workgroup_calculator,
ShaderCode code) {
// Calculate workgroup size.
uint3 workgroup_size = workgroup_calculator.Calculate(code);
uint3 num_workgroups = IntegralDivideRoundUp(code.workload, workgroup_size);
for (const auto& object : code.objects) {
if (IsRef(object)) {
object_sizes_[GetRef(object)] = ByteSizeOf(object);
}
}
// Store full shader and compile it if necessary.
size_t shader_idx;
RETURN_IF_ERROR(
AddFullShader(code.source_code, workgroup_size, &shader_idx));
programs_.push_back({
std::move(code.parameters),
std::move(code.objects),
workgroup_size,
num_workgroups,
shader_idx,
});
return OkStatus();
}
// Store full shader and compile it if necessary.
// Returns full_shader_index
Status AddFullShader(const std::string& partial_shader,
const uint3& workgroup_size, size_t* size) {
std::string shader_src = GetShaderHeader(workgroup_size) + partial_shader;
auto it = shader_to_index_.find(shader_src);
if (it == shader_to_index_.end()) {
GlShader shader;
RETURN_IF_ERROR(
GlShader::CompileShader(GL_COMPUTE_SHADER, shader_src, &shader));
shaders_.push_back(std::move(shader));
shader_to_index_.insert({shader_src, shader_to_index_.size()});
*size = shader_to_index_.size() - 1;
} else {
*size = it->second;
}
return OkStatus();
}
Status NewRun(
const RuntimeOptions& options, const ObjectManager* objects,
CommandQueue* command_queue,
std::unique_ptr<InferenceContext>* inference_context) const final {
std::unique_ptr<ObjectManager> refs;
if (dynamic_batch_) {
// Runtime is using objects from refs that will point to provided objects.
// At this point just create 0 batch slice references.
refs = absl::make_unique<ObjectManager>();
for (const auto& s : object_sizes_) {
auto buffer = objects->FindBuffer(s.first);
if (!buffer) continue;
GlBuffer ref;
RETURN_IF_ERROR(buffer->MakeView(0, s.second, &ref));
RETURN_IF_ERROR(refs->RegisterBuffer(s.first, std::move(ref)));
}
}
auto runtime = absl::make_unique<Runtime>(options, gpu_info_, command_queue,
refs ? refs.get() : objects);
for (auto& c : programs_) {
RETURN_IF_ERROR(runtime->AddProgram(shaders_[c.shader_idx], c.parameters,
c.objects, c.num_workgroups));
}
RETURN_IF_ERROR(runtime->PrepareForExecution());
if (dynamic_batch_) {
*inference_context = absl::make_unique<InferenceContextWithBatchImpl>(
object_sizes_, objects, std::move(refs), std::move(runtime));
} else {
*inference_context =
absl::make_unique<InferenceContextImpl>(std::move(runtime));
}
return OkStatus();
}
#ifndef TFLITE_GPU_BINARY_RELEASE
// Called on deserialization
Status OnProgram(const std::vector<UniformParameter>& parameters,
const std::vector<Object>& objects,
const uint3& workgroup_size, const uint3& num_workgroups,
size_t partial_shader_index) final {
for (auto& object : objects) {
if (IsRef(object)) {
object_sizes_[GetRef(object)] = ByteSizeOf(object);
}
}
size_t shader_idx;
RETURN_IF_ERROR(AddFullShader(partial_shaders_[partial_shader_index],
workgroup_size, &shader_idx));
programs_.push_back({
parameters,
objects,
workgroup_size,
num_workgroups,
shader_idx,
});
return OkStatus();
}
Status Serialize(
std::vector<uint8_t>* serialized_compiled_model) const final {
SerializedCompiledModelBuilder builder;
// sort shaders first. They need to be serialized in order.
std::vector<std::string> full_shaders(shaders_.size());
for (const auto& shader : shader_to_index_) {
full_shaders[shader.second] = shader.first;
}
std::unordered_map<std::string, size_t> partial_shader_to_index;
std::vector<std::string> partial_shaders;
for (const auto& program : programs_) {
// Remove a header from a shader.
std::string shader_without_header = full_shaders[program.shader_idx];
shader_without_header.erase(0, shader_without_header.find("in;") + 3);
// Insert shader into partial shaders array.
auto it = partial_shader_to_index.find(shader_without_header);
size_t shader_idx;
if (it == partial_shader_to_index.end()) {
shader_idx = partial_shaders.size();
partial_shaders.push_back(shader_without_header);
builder.AddShader(shader_without_header);
partial_shader_to_index.insert({shader_without_header, shader_idx});
} else {
shader_idx = it->second;
}
builder.AddProgram(program.parameters, program.objects,
program.workgroup_size, program.num_workgroups,
shader_idx);
}
CompiledModelOptions options;
options.dynamic_batch = dynamic_batch_;
auto data = builder.Finalize(options);
serialized_compiled_model->insert(serialized_compiled_model->end(),
data.begin(), data.end());
return OkStatus();
}
Status OnShader(absl::Span<const char> shader_src) final {
std::string source(shader_src.data(), shader_src.size());
partial_shaders_.push_back(source);
return OkStatus();
}
void OnOptions(const CompiledModelOptions& options) final {
dynamic_batch_ = options.dynamic_batch;
}
#endif // TFLITE_GPU_BINARY_RELEASE
CompilerStats stats() const final { return stats_; }
void set_dynamic_batch(bool dynamic_batch) { dynamic_batch_ = dynamic_batch; }
private:
const GpuInfo gpu_info_;
bool dynamic_batch_ = false;
std::vector<std::string> partial_shaders_;
std::vector<GlShader> shaders_;
// Shaders are serialized in order of their indices.
std::unordered_map<std::string, size_t> shader_to_index_;
std::deque<ProgramParameters> programs_;
std::unordered_map<ValueId, size_t> object_sizes_;
CompilerStats stats_;
};
// @return true if all tensors have same batch value.
bool IsBatchMatchesForAllValues(const GraphFloat32& model) {
const int32_t b = model.values()[0]->tensor.shape.b;
for (auto value : model.values()) {
if (value->tensor.shape.b != b) {
return false;
}
}
return true;
}
bool IsOpenGl31OrAbove(const GpuInfo& gpu_info) {
return (gpu_info.major_version == 3 && gpu_info.minor_version >= 1) ||
gpu_info.major_version > 3;
}
} // namespace
Status Compile(const CompilationOptions& options, const GraphFloat32& model,
const std::unordered_set<int>& tflite_graph_io,
const NodeShader& node_shader,
const WorkgroupsCalculator& workgroup_calculator,
std::unique_ptr<CompiledModel>* compiled_model) {
if (!IsBatchMatchesForAllValues(model)) {
return InvalidArgumentError("Only identical batch dimension is supported");
}
GpuInfo gpu_info;
RETURN_IF_ERROR(RequestGpuInfo(&gpu_info));
if (!IsOpenGl31OrAbove(gpu_info)) {
return InternalError(
"OpenGL ES 3.1 or above is required to use OpenGL inference.");
}
auto compiled_model_impl = absl::make_unique<CompiledModelImpl>(gpu_info);
compiled_model_impl->set_dynamic_batch(options.dynamic_batch);
auto compiler = NewCompiler(&node_shader, &gpu_info, options);
RETURN_IF_ERROR(
compiler->Compile(model, tflite_graph_io, [&](ShaderCode code) -> Status {
return compiled_model_impl->Add(workgroup_calculator, std::move(code));
}));
*compiled_model = std::move(compiled_model_impl);
return OkStatus();
}
#ifndef TFLITE_GPU_BINARY_RELEASE
Status ReadSerializedModel(const std::vector<uint8_t>& serialized_model,
std::unique_ptr<CompiledModel>* compiled_model) {
GpuInfo gpu_info;
RETURN_IF_ERROR(RequestGpuInfo(&gpu_info));
if (!IsOpenGl31OrAbove(gpu_info)) {
return InternalError(
"OpenGL ES 3.1 or above is required to use OpenGL inference.");
}
auto compiled_model_impl = absl::make_unique<CompiledModelImpl>(gpu_info);
RETURN_IF_ERROR(DeserializeCompiledModel(
absl::MakeConstSpan(serialized_model), compiled_model_impl.get()));
*compiled_model = std::move(compiled_model_impl);
return OkStatus();
}
#endif // TFLITE_GPU_BINARY_RELEASE
} // namespace gl
} // namespace gpu
} // namespace tflite
|
/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: b2dpolypolygoncutter.hxx,v $
*
* $Revision: 1.8 $
*
* last change: $Author: kz $ $Date: 2005-11-02 13:53:46 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
#ifndef _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
#define _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
//#ifndef _SAL_TYPES_H_
//#include <sal/types.h>
//#endif
//
//#ifndef _BGFX_POINT_B2DPOINT_HXX
//#include <basegfx/point/b2dpoint.hxx>
//#endif
//
//#ifndef _BGFX_RANGE_B2DRANGE_HXX
//#include <basegfx/range/b2drange.hxx>
//#endif
#ifndef _BGFX_POLYGON_B2DPOLYPOLYGON_HXX
#include <basegfx/polygon/b2dpolypolygon.hxx>
#endif
//#include <vector>
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
namespace tools
{
// solve all crossovers in a polyPolygon. This re-layouts all contained polygons so that the
// result will contain only non-cutting polygons. For that reason, points will be added at
// crossover and touch points and the single Polygons may be re-combined. The orientations
// of the contained polygons in not changed but used as hints.
// If bSelfCrossovers is set, first all self-intersections of the contained polygons will be
// solved.
B2DPolyPolygon SolveCrossovers(const B2DPolyPolygon& rCandidate, bool bSelfCrossovers = true);
// version for single polygons. This is for solving self-intersections. Result will be free of
// crossovers. When result contains multiple polygons, it may be necessary to rearrange their
// orientations since holes may have been created (use correctOrientations eventually).
B2DPolyPolygon SolveCrossovers(const B2DPolygon& rCandidate);
// Neutral polygons will be stripped. Neutral polygons are ones who's orientation is
// neutral, so normally they have no volume -> just closed paths. A polygon with the same
// positive and negative oriented volume is also neutral, so this may not be wanted. It is
// safe to call with crossover-free polygons, though (that's where it's mostly used).
B2DPolyPolygon StripNeutralPolygons(const B2DPolyPolygon& rCandidate);
// Remove not necessary polygons. Works only correct with crossover-free polygons. For each
// polygon, the depth for the PolyPolygon is calculated. The orientation is used to identify holes.
// Start value for holes is -1, for polygons it's zero. Ech time a polygon is contained in another one,
// it's depth is increased when inside a polygon, decreased when inside a hole. The result is a depth
// which e.g. is -1 for holes outside everything, 1 for a polygon covered by another polygon and zero
// for e.g. holes in a polygon or polygons outside everythig else.
// In the 2nd step, all polygons with depth other than zero are removed. If bKeepAboveZero is used,
// all polygons < 1 are removed. The bKeepAboveZero mode is useful for clipping, e.g. just append
// one polygon to another and use this mode -> only parts where two polygons overlapped will be kept.
// In combination with correct orientation of the input orientations and the SolveCrossover calls this
// can be combined for logical polygon operations or polygon clipping.
B2DPolyPolygon StripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false);
} // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
#endif /* _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX */
INTEGRATION: CWS changefileheader (1.8.80); FILE MERGED
2008/04/01 10:48:08 thb 1.8.80.2: #i85898# Stripping all external header guards
2008/03/28 16:05:41 rt 1.8.80.1: #i87441# Change license header to LPGL v3.
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: b2dpolypolygoncutter.hxx,v $
* $Revision: 1.9 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
#define _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX
//#ifndef _SAL_TYPES_H_
//#include <sal/types.h>
//#endif
//
//#ifndef _BGFX_POINT_B2DPOINT_HXX
//#include <basegfx/point/b2dpoint.hxx>
//#endif
//
//#ifndef _BGFX_RANGE_B2DRANGE_HXX
//#include <basegfx/range/b2drange.hxx>
//#endif
#include <basegfx/polygon/b2dpolypolygon.hxx>
//#include <vector>
//////////////////////////////////////////////////////////////////////////////
namespace basegfx
{
namespace tools
{
// solve all crossovers in a polyPolygon. This re-layouts all contained polygons so that the
// result will contain only non-cutting polygons. For that reason, points will be added at
// crossover and touch points and the single Polygons may be re-combined. The orientations
// of the contained polygons in not changed but used as hints.
// If bSelfCrossovers is set, first all self-intersections of the contained polygons will be
// solved.
B2DPolyPolygon SolveCrossovers(const B2DPolyPolygon& rCandidate, bool bSelfCrossovers = true);
// version for single polygons. This is for solving self-intersections. Result will be free of
// crossovers. When result contains multiple polygons, it may be necessary to rearrange their
// orientations since holes may have been created (use correctOrientations eventually).
B2DPolyPolygon SolveCrossovers(const B2DPolygon& rCandidate);
// Neutral polygons will be stripped. Neutral polygons are ones who's orientation is
// neutral, so normally they have no volume -> just closed paths. A polygon with the same
// positive and negative oriented volume is also neutral, so this may not be wanted. It is
// safe to call with crossover-free polygons, though (that's where it's mostly used).
B2DPolyPolygon StripNeutralPolygons(const B2DPolyPolygon& rCandidate);
// Remove not necessary polygons. Works only correct with crossover-free polygons. For each
// polygon, the depth for the PolyPolygon is calculated. The orientation is used to identify holes.
// Start value for holes is -1, for polygons it's zero. Ech time a polygon is contained in another one,
// it's depth is increased when inside a polygon, decreased when inside a hole. The result is a depth
// which e.g. is -1 for holes outside everything, 1 for a polygon covered by another polygon and zero
// for e.g. holes in a polygon or polygons outside everythig else.
// In the 2nd step, all polygons with depth other than zero are removed. If bKeepAboveZero is used,
// all polygons < 1 are removed. The bKeepAboveZero mode is useful for clipping, e.g. just append
// one polygon to another and use this mode -> only parts where two polygons overlapped will be kept.
// In combination with correct orientation of the input orientations and the SolveCrossover calls this
// can be combined for logical polygon operations or polygon clipping.
B2DPolyPolygon StripDispensablePolygons(const B2DPolyPolygon& rCandidate, bool bKeepAboveZero = false);
} // end of namespace tools
} // end of namespace basegfx
//////////////////////////////////////////////////////////////////////////////
#endif /* _BGFX_POLYGON_B2DPOLYPOLYGONCUTTER_HXX */
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: DomainMapper.cxx,v $
*
* $Revision: 1.69 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include "PageBordersHandler.hxx"
#include <dmapper/DomainMapper.hxx>
#include <DomainMapper_Impl.hxx>
#include <ConversionHelper.hxx>
#include <ThemeTable.hxx>
#include <ModelEventListener.hxx>
#include <MeasureHandler.hxx>
#include <OLEHandler.hxx>
#include <i18npool/mslangid.hxx>
#include <i18npool/paper.hxx>
#include <ooxml/OOXMLFastTokens.hxx>
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#include <com/sun/star/document/XOOXMLDocumentPropertiesImporter.hpp>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/RelOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/WrapTextMode.hpp>
#include <com/sun/star/text/SizeType.hpp>
#include <com/sun/star/text/XEndnotesSupplier.hpp>
#include <com/sun/star/text/XFootnotesSupplier.hpp>
#include <com/sun/star/text/XLineNumberingProperties.hpp>
#include <com/sun/star/text/XTextDocument.hpp>
#include <com/sun/star/text/XTextCursor.hpp>
#include <com/sun/star/text/XTextPortionAppend.hpp>
#include <com/sun/star/text/XParagraphAppend.hpp>
#include <com/sun/star/text/FontEmphasis.hpp>
#include <com/sun/star/awt/FontRelief.hpp>
#include <com/sun/star/awt/FontWeight.hpp>
#include <com/sun/star/awt/FontUnderline.hpp>
#include <com/sun/star/awt/FontStrikeout.hpp>
#include <com/sun/star/awt/FontSlant.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/document/XEventBroadcaster.hpp>
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/style/BreakType.hpp>
#include <com/sun/star/style/CaseMap.hpp>
#include <com/sun/star/style/LineSpacing.hpp>
#include <com/sun/star/style/LineSpacingMode.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <com/sun/star/text/TextGridMode.hpp>
#include <com/sun/star/text/XDocumentIndexesSupplier.hpp>
#include <com/sun/star/text/WritingMode.hpp>
#include <com/sun/star/text/WritingMode2.hpp>
#include <com/sun/star/text/XFootnote.hpp>
#include <com/sun/star/style/NumberingType.hpp>
#include <comphelper/types.hxx>
#include <comphelper/storagehelper.hxx>
#include <rtl/ustrbuf.hxx>
#include <boost/shared_ptr.hpp>
#include <com/sun/star/uno/Any.hxx>
#include <tools/color.hxx>
#include <BorderHandler.hxx>
#include <CellColorHandler.hxx>
#include <SectionColumnHandler.hxx>
#include <vector>
#include <iostream>
#ifdef DEBUG_DOMAINMAPPER
#include <resourcemodel/QNameToString.hxx>
#include <resourcemodel/util.hxx>
#include <resourcemodel/TagLogger.hxx>
#endif
#if OSL_DEBUG_LEVEL > 0
#include <resourcemodel/QNameToString.hxx>
#endif
using namespace ::com::sun::star;
using namespace ::rtl;
namespace writerfilter {
namespace dmapper{
#ifdef DEBUG_DOMAINMAPPER
TagLogger::Pointer_t dmapper_logger(TagLogger::getInstance("DOMAINMAPPER"));
#endif
/* ---- Fridrich's mess begins here ---- */
struct _PageSz
{
sal_Int32 code;
sal_Int32 h;
bool orient;
sal_Int32 w;
} CT_PageSz;
/* ---- Fridrich's mess (hopefully) ends here ---- */
/*-- 09.06.2006 09:52:11---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::DomainMapper( const uno::Reference< uno::XComponentContext >& xContext,
uno::Reference< io::XInputStream > xInputStream,
uno::Reference< lang::XComponent > xModel,
SourceDocumentType eDocumentType) :
m_pImpl( new DomainMapper_Impl( *this, xContext, xModel, eDocumentType )),
mnBackgroundColor(0), mbIsHighlightSet(false)
{
// #i24363# tab stops relative to indent
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_TABS_RELATIVE_TO_INDENT ),
uno::makeAny( false ) );
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_PARA_TABLE_SPACING ),
uno::makeAny( false ) );
//import document properties
try
{
uno::Reference< lang::XMultiServiceFactory > xFactory(xContext->getServiceManager(), uno::UNO_QUERY_THROW);
uno::Reference< embed::XStorage > xDocumentStorage =
(comphelper::OStorageHelper::GetStorageOfFormatFromInputStream(OFOPXML_STORAGE_FORMAT_STRING, xInputStream));
uno::Reference< uno::XInterface > xTemp = xContext->getServiceManager()->createInstanceWithContext(
::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.OOXMLDocumentPropertiesImporter")),
xContext);
uno::Reference< document::XOOXMLDocumentPropertiesImporter > xImporter( xTemp, uno::UNO_QUERY_THROW );
uno::Reference< document::XDocumentPropertiesSupplier > xPropSupplier( xModel, uno::UNO_QUERY_THROW);
xImporter->importProperties( xDocumentStorage, xPropSupplier->getDocumentProperties() );
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::~DomainMapper()
{
try
{
uno::Reference< text::XDocumentIndexesSupplier> xIndexesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
uno::Reference< container::XIndexAccess > xIndexes = xIndexesSupplier->getDocumentIndexes();
sal_Int32 nIndexes = xIndexes->getCount();
if( nIndexes )
{
//index update has to wait until first view is created
uno::Reference< document::XEventBroadcaster > xBroadcaster(xIndexesSupplier, uno::UNO_QUERY);
xBroadcaster->addEventListener(uno::Reference< document::XEventListener >(new ModelEventListener));
}
// Apply the document settings after everything else
m_pImpl->GetSettingsTable()->ApplyProperties( m_pImpl->GetTextDocument( ) );
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
delete m_pImpl;
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::attribute(Id nName, Value & val)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("attribute");
dmapper_logger->attribute("name", (*QNameToString::Instance())(nName));
dmapper_logger->attribute("value", val.toString());
dmapper_logger->endElement("attribute");
#endif
static ::rtl::OUString sLocalBookmarkName;
sal_Int32 nIntValue = val.getInt();
rtl::OUString sStringValue = val.getString();
SectionPropertyMap * pSectionContext = m_pImpl->GetSectionContext();
// printf ( "DomainMapper::attribute(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nName, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
if( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR )
m_pImpl->GetFIB().SetData( nName, nIntValue );
else //if( !m_pImpl->getTableManager().attribute( nName, val) )
{
/* WRITERFILTERSTATUS: table: attributedata */
switch( nName )
{
/* attributes to be ignored */
case NS_rtf::LN_UNUSED1_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED1_7:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED8_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWRITERESERVATION:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FFAREAST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRYPTO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_NFIBBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LKEY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_ENVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWORD97SAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTECHP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTEPAP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTELVC_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CBMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CCPMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWLOWDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWHIGHDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_rtf::LN_ISTD: //index of applied style
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//search for the style with the given id and apply it
//as CharStyleName or ParaStyleName
//if the style is a user defined style then it must have an ISTD - built-in styles might not have it
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
::rtl::OUString sValue = ::rtl::OUString::valueOf(nIntValue, 16);
const StyleSheetEntryPtr pEntry = pStyleSheets->FindStyleSheetByISTD(sValue);
if( pEntry.get( ) )
{
bool bParaStyle = (pEntry->nStyleTypeCode == STYLE_TYPE_PARA);
if(bParaStyle)
m_pImpl->SetCurrentParaStyleId(::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16));
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert(
bParaStyle ?
PROP_PARA_STYLE_NAME : PROP_CHAR_STYLE_NAME,
true,
uno::makeAny(
m_pImpl->GetStyleSheetTable()->ConvertStyleName( pEntry->sStyleName ) ) );
}
}
break;
case NS_rtf::LN_ISTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NFC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FLEGAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FNORESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FIDENTSAV:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FCONVERTED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FTENTATIVE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGBXCHNUMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IXCHFOLLOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXASPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAINDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLCHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LSID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_TPLC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGISTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSIMPLELIST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fAutoNum:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fHybrid:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ILVL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFORMATTING:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNSIGNED4_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_clfolvl:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBFFNM1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PRQ:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FTRUETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WWEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CHS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetLNCHS( nIntValue );
}
break;
case NS_rtf::LN_IXCHSZALT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PANOSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STI:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSCRATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FINVALHEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHASUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMASSCOPY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SGC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDBASE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CUPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BCHUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FAUTOREDEF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHIDDEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CSTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBSTDBASEINFILE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTDSTYLENAMESWRITTEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED4_2:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STIMAXWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDMAXFIXEDWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NVERBUILTINNAMESWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGFTCSTANDARDCHPSTSH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WIDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NFIB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NPRODUCT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FDOT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCOMPLEX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FHASPIC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CQUICKSAVES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FENCRYPTED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FWHICHTBLSTM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FREADONLYRECOMMENDED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEXTCHAR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEMPTYSPECIAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDEPAGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FFUTURESAVEDUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FSPARE0:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CHSTABLES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CSW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LIDFE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CLW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTECHP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTEPAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CFCLCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetData( nName, nIntValue );
}
break;
case NS_rtf::LN_FN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSEPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FNMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//section descriptor, unused or internally used
break;
case NS_rtf::LN_ICOFORE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICOBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IPAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDFORECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDBACKCOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDPATTERN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTLINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTSPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSHADOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED2_15:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFIRSTMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBACKWARD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FROTATEFONT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTMERGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTRESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_VERTALIGN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
(void)nLineDistance;
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nName )
{
case NS_rtf::LN_BRCTOP:
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCLEFT:
// eBorderId = PROP_LEFT_BORDER;
// eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_rtf::LN_BRCBOTTOM:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCRIGHT:
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
default:;
}
//todo: where to put the border properties
//rContext->Insert(eBorderId, uno::makeAny( aBorderLine ));
//rContext->Insert(eBorderDistId, uno::makeAny( nLineDistance ));
}
break;
case NS_rtf::LN_ITCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPUB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ITCLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FCOL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_YEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_HMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBHEADER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MFP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BM_RCWINMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAMEEMPTY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBITMAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FDRAWHATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FERROR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BPP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CPROPS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSHORIZONTAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_endnote:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BOOKMARKNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// sStringValue contains the bookmark name
sLocalBookmarkName = sStringValue;
break;
case NS_rtf::LN_IBKL:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0.5 */
//contains the bookmark identifier - has to be added to the bookmark name imported before
//if it is already available then the bookmark should be inserted
m_pImpl->AddBookmark( sLocalBookmarkName, sStringValue );
sLocalBookmarkName = ::rtl::OUString();
break;
case NS_rtf::LN_LISTLEVEL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFOData:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_F:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ALTFONTNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSZFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPXSTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_sed:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//section properties
resolveAttributeProperties(val);
break;
case NS_rtf::LN_tbdAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
{
pProperties->resolve(*this);
//increment to the next tab stop
m_pImpl->NextTabStop();
}
}
break;
case NS_rtf::LN_dxaDel:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//deleted tab
case NS_rtf::LN_dxaAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//set tab
case NS_rtf::LN_TLC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab leading characters - for decimal tabs
case NS_rtf::LN_JC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab justification
m_pImpl->ModifyCurrentTabStop(nName, nIntValue);
break;
case NS_rtf::LN_UNUSED0_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// really unused
break;
case NS_rtf::LN_rgbrc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_shd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellShd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellTopColor:
case NS_rtf::LN_cellLeftColor:
case NS_rtf::LN_cellBottomColor:
case NS_rtf::LN_cellRightColor:
OSL_ASSERT("handled by DomainMapperTableManager");
break;
case NS_rtf::LN_LISTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fcEastAsianLayout:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
/* it seems that the value is following:
???? XX YYYY ZZ
where
XX seems to be the run id
ZZ is the length of the function that is normally 6
Lower byte of YYYY determines whether it is
vertical text flow (0x01), or
two lines in one layout (0x02).
For 0x01, if the higher byte of YYYY is zero, the text is not scaled to fit the line height,
in oposite case, it is to be scaled.
For 0x02, the higher byte of YYYY is determinig the prefix and suffix of the run:
no brackets (0x00) ,
() round brackets (0x01),
[] square backets (0x02),
<> angle brackets (0x03) and
{} curly brackets (0x04).
???? is different and we do not know its signification
*/
if ((nIntValue & 0x000000FF) == 6)
{
switch ((nIntValue & 0x0000FF00) >> 8)
{
case 1: // vertical text
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( sal_Int16(900) ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny (((nIntValue & 0x00FF0000) >> 16) != 0));
}
break;
case 2: // two lines in one
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( true ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16)));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16, false)));
}
break;
default:
break;
}
}
break;
case NS_rtf::LN_FRD :
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnote reference descriptor, if nIntValue > 0 then automatic, custom otherwise
//ignored
break;
case NS_rtf::LN_FONT: //font of footnote symbol
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteFontId( nIntValue );
break;
case NS_ooxml::LN_CT_Sym_char:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
m_pImpl->GetTopContext()->GetFootnote()->setLabel(::rtl::OUString( sal_Unicode(nIntValue)));
break;
}
else //it's a _real_ symbol
{
utext( reinterpret_cast < const sal_uInt8 * >( &nIntValue ), 1 );
}
break;
case NS_rtf::LN_CHAR: //footnote symbol character
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteSymbol( sal_Unicode(nIntValue));
break;
case NS_ooxml::LN_CT_Sym_font:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//the footnote symbol and font are provided after the footnote is already inserted
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
uno::Reference< beans::XPropertySet > xAnchorProps( m_pImpl->GetTopContext()->GetFootnote()->getAnchor(), uno::UNO_QUERY );
xAnchorProps->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_CHAR_FONT_NAME),
uno::makeAny( sStringValue ));
}
else //a real symbol
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Underline_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
handleUnderlineType(nIntValue, m_pImpl->GetTopContext());
break;
case NS_ooxml::LN_CT_Color_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nIntValue ) );
break;
case NS_ooxml::LN_CT_Underline_color:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nIntValue ) );
}
break;
case NS_ooxml::LN_CT_TabStop_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_ST_TabJc_clear)
m_pImpl->m_aCurrentTabStop.bDeleted = true;
else
{
m_pImpl->m_aCurrentTabStop.bDeleted = false;
m_pImpl->m_aCurrentTabStop.Alignment = getTabAlignFromValue(nIntValue);
}
break;
case NS_ooxml::LN_CT_TabStop_leader:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.FillChar = getFillCharFromValue(nIntValue);
break;
case NS_ooxml::LN_CT_TabStop_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.Position = ConversionHelper::convertTwipToMM100(nIntValue);
break;
case NS_ooxml::LN_CT_Fonts_ascii:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_asciiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Fonts_hAnsi:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;//unsupported
case NS_ooxml::LN_CT_Fonts_hAnsiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break; //unsupported
case NS_ooxml::LN_CT_Fonts_eastAsia:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_ASIAN, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_eastAsiaTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ) );
break;
case NS_ooxml::LN_CT_Fonts_cs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_cstheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Spacing_before:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_beforeLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_after:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_afterLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_line: //91434
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Spacing_lineRule: //91435
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
#define SINGLE_LINE_SPACING 240
style::LineSpacing aSpacing;
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
PropertyMap::iterator aLineSpacingIter = pTopContext->find(PropertyDefinition( PROP_PARA_LINE_SPACING, true ) );
if( aLineSpacingIter != pTopContext->end())
{
aLineSpacingIter->second >>= aSpacing;
}
else
{
//default to single line spacing
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
if( nName == NS_ooxml::LN_CT_Spacing_line )
{
//now set the value depending on the Mode
if( aSpacing.Mode == style::LineSpacingMode::PROP )
aSpacing.Height = sal_Int16(sal_Int32(nIntValue) * 100 / SINGLE_LINE_SPACING );
else
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( nIntValue ));
}
else //NS_ooxml::LN_CT_Spacing_lineRule:
{
// exactly, atLeast, auto
if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_auto)
{
aSpacing.Mode = style::LineSpacingMode::PROP;
//reinterpret the already set value
aSpacing.Height = sal_Int16( aSpacing.Height * 100 / ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
else if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_atLeast)
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
else // NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_exact
aSpacing.Mode = style::LineSpacingMode::FIX;
}
pTopContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case NS_ooxml::LN_CT_Ind_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_LEFT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_RIGHT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_hanging:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( - ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_firstLine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_EastAsianLayout_combine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( nIntValue ? true : false ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_combineBrackets:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
rtl::OUString sCombinePrefix = getBracketStringFromEnum(nIntValue);
rtl::OUString sCombineSuffix = getBracketStringFromEnum(nIntValue, false);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( sCombinePrefix ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( sCombineSuffix ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vert:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
sal_Int16 nRotationAngle = (nIntValue ? 900 : 0);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( nRotationAngle ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vertCompress:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny ( nIntValue ? true : false));
break;
case NS_ooxml::LN_CT_PageSz_code:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = nIntValue;
break;
case NS_ooxml::LN_CT_PageSz_h:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.h = PaperInfo::sloppyFitPageDimension(nHeight);
}
break;
case NS_ooxml::LN_CT_PageSz_orient:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.orient = (nIntValue != 0);
break;
case NS_ooxml::LN_CT_PageSz_w:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.w = PaperInfo::sloppyFitPageDimension(nWidth);
}
break;
case NS_ooxml::LN_CT_PageMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_TOP, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_RIGHT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_BOTTOM, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_LEFT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_header:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_HEADER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_footer:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_FOOTER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_gutter:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_GUTTER, nIntValue );
break;
case NS_ooxml::LN_CT_Language_val: //90314
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_eastAsia: //90315
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_bidi: //90316
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
LanguageType eLang = MsLangId::convertIsoStringToLanguage( sStringValue );
lang::Locale aLocale = MsLangId::convertLanguageToLocale( eLang );
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(NS_ooxml::LN_CT_Language_val== nName ? PROP_CHAR_LOCALE :
NS_ooxml::LN_CT_Language_eastAsia == nName ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
#define AUTO_PARA_SPACING sal_Int32(49)
case NS_ooxml::LN_CT_Spacing_beforeAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
//and should be set to 0 on start of page
m_pImpl->GetTopContext()->Insert( PROP_PARA_TOP_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_Spacing_afterAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
m_pImpl->GetTopContext()->Insert( PROP_PARA_BOTTOM_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_SmartTagRun_uri:
case NS_ooxml::LN_CT_SmartTagRun_element:
/* WRITERFILTERSTATUS: done: 0, planned: 1, spent: 0 */
//TODO: add handling of SmartTags
break;
case NS_ooxml::LN_CT_Br_type :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//TODO: attributes for break (0x12) are not supported
break;
case NS_ooxml::LN_CT_Fonts_hint :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
/* assigns script type to ambigous characters, values can be:
NS_ooxml::LN_Value_ST_Hint_default
NS_ooxml::LN_Value_ST_Hint_eastAsia
NS_ooxml::LN_Value_ST_Hint_cs
*/
//TODO: unsupported?
break;
case NS_ooxml::LN_CT_TblCellMar_right: // 92375;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_top: // 92377;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_left: // 92378;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_bottom: // 92379;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//todo: handle cell mar
break;
case NS_rtf::LN_blip: // contains the binary graphic
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_shape:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
{
//looks a bit like a hack - and it is. The graphic import is split into the inline_inline part and
//afterwards the adding of the binary data.
m_pImpl->GetGraphicImport( IMPORT_AS_DETECTED_INLINE )->attribute(nName, val);
m_pImpl->ImportGraphic( val.getProperties(), IMPORT_AS_DETECTED_INLINE );
}
break;
case NS_ooxml::LN_CT_FramePr_dropCap:
case NS_ooxml::LN_CT_FramePr_lines:
case NS_ooxml::LN_CT_FramePr_hAnchor:
case NS_ooxml::LN_CT_FramePr_vAnchor:
case NS_ooxml::LN_CT_FramePr_x:
case NS_ooxml::LN_CT_FramePr_xAlign:
case NS_ooxml::LN_CT_FramePr_y:
case NS_ooxml::LN_CT_FramePr_yAlign:
case NS_ooxml::LN_CT_FramePr_hRule:
case NS_sprm::LN_PWr:
case NS_sprm::LN_PDxaWidth:
case NS_sprm::LN_PWHeightAbs:
case NS_sprm::LN_PDxaFromText:
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
ParagraphProperties* pParaProperties = dynamic_cast< ParagraphProperties*>(m_pImpl->GetTopContext().get());
if( pParaProperties )
{
switch( nName )
{
case NS_ooxml::LN_CT_FramePr_dropCap:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetDropCap( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_lines:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetLines( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_text: //relative to column
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_margin: nIntValue = text::RelOrientation::PAGE_PRINT_AREA; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SethAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_vAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_text: //relative to paragraph
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_margin:nIntValue = text::RelOrientation::PAGE_PRINT_AREA ; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SetvAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_x:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setx( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_xAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_center : nIntValue = text::HoriOrientation::CENTER; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_right : nIntValue = text::HoriOrientation::RIGHT; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_inside : nIntValue = text::HoriOrientation::INSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_outside : nIntValue = text::HoriOrientation::OUTSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_left : nIntValue = text::HoriOrientation::LEFT; break;
default: nIntValue = text::HoriOrientation::NONE;
}
pParaProperties->SetxAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_y:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Sety( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_yAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_top :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inside :nIntValue = text::VertOrientation::TOP; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_center :nIntValue = text::VertOrientation::CENTER;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_bottom :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_outside :nIntValue = text::VertOrientation::BOTTOM;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inline ://todo: what to do with inline - no avail. in WW97 and WW2007
//no break;
default:nIntValue = text::VertOrientation::NONE;
}
pParaProperties->SetyAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hRule:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_exact:
nIntValue = text::SizeType::FIX;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_atLeast:
nIntValue = text::SizeType::MIN;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_auto:
//no break;
default:;
nIntValue = text::SizeType::VARIABLE;
}
pParaProperties->SethRule( nIntValue );
break;
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//should be either LN_Value_wordprocessingml_ST_Wrap_notBeside or LN_Value_wordprocessingml_ST_Wrap_around
OSL_ENSURE( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ||
sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_notBeside,
"wrap not around or not_Beside?");
pParaProperties->SetWrap(sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ?
text::WrapTextMode_DYNAMIC : text::WrapTextMode_NONE );
}
break;
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setw(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Seth(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SethSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetvSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
default:;
}
}
else
{
//TODO: how to handle frame properties at styles
}
}
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TrackChange_author:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineAuthor( sStringValue );
break;
case NS_ooxml::LN_CT_TrackChange_date:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineDate( sStringValue );
break;
case NS_ooxml::LN_CT_Markup_id:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineId( nIntValue );
break;
case NS_ooxml::LN_token:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineToken( nIntValue );
break;
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
//line numbering in Writer is a global document setting
//in Word is a section setting
//if line numbering is switched on anywhere in the document it's set at the global settings
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
switch( nName )
{
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nInterval = nIntValue;
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nStartValue = nIntValue; // todo: has to be set at (each) first paragraph
break;
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nDistance = ConversionHelper::convertTwipToMM100( nIntValue );
break;
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page:empty, probably 0,section:1,continuous:2;
aSettings.bRestartAtEachPage = nIntValue < 1;
break;
default:;
}
m_pImpl->SetLineNumberSettings( aSettings );
}
break;
case NS_ooxml::LN_CT_FtnEdnRef_customMarkFollows:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCustomFtnMark( true );
break;
case NS_ooxml::LN_CT_FtnEdnRef_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// footnote or endnote reference id - not needed
case NS_ooxml::LN_CT_Color_themeColor:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeTint:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeShade:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//unsupported
break;
case NS_ooxml::LN_endtrackchange:
m_pImpl->RemoveCurrentRedline( );
break;
case NS_ooxml::LN_CT_DocGrid_linePitch:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//see SwWW8ImplReader::SetDocumentGrid
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetGridLinePitch( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case NS_ooxml::LN_CT_DocGrid_charSpace:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDxtCharSpace( nIntValue );
}
}
break;
case NS_ooxml::LN_CT_DocGrid_type:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
if (pSectionContext != NULL)
{
pSectionContext->SetGridType(nIntValue);
}
}
break;
default:
{
#if OSL_DEBUG_LEVEL > 0
::rtl::OString sMessage( "DomainMapper::attribute() - Id: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 16 );
// sMessage += ::rtl::OString(" / ");
// sMessage += ::rtl::OString
// ((*QNameToString::Instance())(nName).c_str());
sMessage += ::rtl::OString(" value: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 16 );
OSL_ENSURE( false, sMessage.getStr()); //
#endif
}
}
}
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm(Sprm & rSprm)
{
if( !m_pImpl->getTableManager().sprm(rSprm))
DomainMapper::sprm( rSprm, m_pImpl->GetTopContext() );
}
/*-- 20.06.2006 09:58:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm( Sprm& rSprm, PropertyMapPtr rContext, SprmType eSprmType )
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("sprm");
dmapper_logger->chars(rSprm.toString());
#endif
OSL_ENSURE(rContext.get(), "PropertyMap has to be valid!");
if(!rContext.get())
return ;
sal_uInt32 nSprmId = rSprm.getId();
//needed for page properties
SectionPropertyMap * pSectionContext = m_pImpl->GetSectionContext();
//TODO: In rtl-paragraphs the meaning of left/right are to be exchanged
bool bExchangeLeftRight = false;
// if( nSprmId == NS_sprm::LN_PJcExtra && AlreadyInRTLPara() )
// bExchangeLeftRight = true;
Value::Pointer_t pValue = rSprm.getValue();
sal_Int32 nIntValue = pValue->getInt();
rtl::OUString sStringValue = pValue->getString();
// printf ( "DomainMapper::sprm(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nSprmId, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
/* WRITERFILTERSTATUS: table: sprmdata */
switch(nSprmId)
{
case 2: // sprmPIstd
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
case 0x4600:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstd - style code
case 3: // "sprmPIstdPermute
case NS_sprm::LN_PIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstdPermute
case NS_sprm::LN_PIncLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIncLvl
case NS_sprm::LN_PJcExtra: // sprmPJc Asian (undocumented)
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PJc: // sprmPJc
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
handleParaJustification(nIntValue, rContext, bExchangeLeftRight);
break;
case NS_sprm::LN_PFSideBySide:
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
break; // sprmPFSideBySide
case NS_sprm::LN_PFKeep: // sprmPFKeep
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_SPLIT, true, uno::makeAny(nIntValue ? false : true));
break;
case NS_sprm::LN_PFKeepFollow: // sprmPFKeepFollow
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_KEEP_TOGETHER, true, uno::makeAny( nIntValue ? true : false) );
break;
case NS_sprm::LN_PFPageBreakBefore:
/* WRITERFILTERSTATUS: done: 100, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE ) );
break; // sprmPFPageBreakBefore
case NS_sprm::LN_PBrcl:
break; // sprmPBrcl
case NS_sprm::LN_PBrcp:
break; // sprmPBrcp
case NS_sprm::LN_PIlvl: // sprmPIlvl
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
//todo: Numbering level will be implemented in the near future (OOo 3.0?)
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListLevel( (sal_Int16)nIntValue );
}
else
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny( (sal_Int16)nIntValue ));
break;
case NS_sprm::LN_PIlfo: // sprmPIlfo
/* WRITERFILTERSTATUS: done: 50, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
{
//convert the ListTable entry to a NumberingRules propery and apply it
sal_Int32 nListId = m_pImpl->GetLFOTable()->GetListID( nIntValue );
if(nListId >= 0)
{
ListTablePtr pListTable = m_pImpl->GetListTable();
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListId( nListId );
}
else
rContext->Insert( PROP_NUMBERING_RULES, true,
uno::makeAny(pListTable->GetNumberingRules(nListId)));
//TODO: Merge overwrittern numbering levels from LFO table
}
}
break;
case NS_sprm::LN_PFNoLineNumb: // sprmPFNoLineNumb
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_LINE_NUMBER_COUNT, true, uno::makeAny( nIntValue ? false : true) );
break;
case NS_sprm::LN_PChgTabsPapx: // sprmPChgTabsPapx
/* WRITERFILTERSTATUS: done: 90, planned: 8, spent: 8 */
/* WRITERFILTERSTATUS: comment: bar tab stops a unavailable */
{
// Initialize tab stop vector from style sheet
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
//create a new tab stop property - this is done with the contained properties
resolveSprmProps(rSprm);
//add this property
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case 0x845d: //right margin Asian - undocumented
case 0x845e: //left margin Asian - undocumented
case 16: // sprmPDxaRight - right margin
case NS_sprm::LN_PDxaRight: // sprmPDxaRight - right margin
case 17:
case NS_sprm::LN_PDxaLeft: // sprmPDxaLeft
/* WRITERFILTERSTATUS: done: 50, planned: 5, spent: 1 */
if( NS_sprm::LN_PDxaLeft == nSprmId || 0x17 == nSprmId|| (bExchangeLeftRight && nSprmId == 0x845d) || ( !bExchangeLeftRight && nSprmId == 0x845e))
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_LEFT_MARGIN : PROP_LEFT_MARGIN,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
else if(eSprmType == SPRM_DEFAULT)
rContext->Insert(
PROP_PARA_RIGHT_MARGIN, true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
//TODO: what happens to the right margins in numberings?
break;
case 18: // sprmPNest
case NS_sprm::LN_PNest: // sprmPNest
//not handled in the old WW8 filter
break;
case NS_sprm::LN_PDxaLeft1: // sprmPDxaLeft1
case 19:
case NS_sprm::LN_PDxaLeft180: // sprmPDxaLeft180
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_FIRST_LINE_INDENT : PROP_FIRST_LINE_OFFSET,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case 20 : // sprmPDyaLine
case NS_sprm::LN_PDyaLine: // sprmPDyaLine
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
{
style::LineSpacing aSpacing;
sal_Int16 nDistance = sal_Int16(nIntValue & 0xffff);
if(nIntValue & 0xffff0000)
{
// single line in Writer is 100, in Word it is 240
aSpacing.Mode = style::LineSpacingMode::PROP;
aSpacing.Height = sal_Int16(sal_Int32(nDistance) * 100 /240);
}
else
{
if(nDistance < 0)
{
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(-nDistance));
}
else if(nDistance >0)
{
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(nDistance));
}
}
rContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case 21 : // legacy version
case NS_sprm::LN_PDyaBefore: // sprmPDyaBefore
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 22 :
case NS_sprm::LN_PDyaAfter: // sprmPDyaAfter
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 23: //sprmPChgTabs
case NS_sprm::LN_PChgTabs: // sprmPChgTabs
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
OSL_ENSURE( false, "unhandled");
//tabs of list level?
break;
case 24: // "sprmPFInTable"
case NS_sprm::LN_PFInTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFInTable
case NS_sprm::LN_PTableDepth: //sprmPTableDepth
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//not handled via sprm but via text( 0x07 )
break;
case 25: // "sprmPTtp" pap.fTtp
case NS_sprm::LN_PFTtp: // sprmPFTtp was: Read_TabRowEnd
break;
case 26: // "sprmPDxaAbs
case NS_sprm::LN_PDxaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaAbs
case 27: //sprmPDyaAbs
case NS_sprm::LN_PDyaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaAbs
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaWidth
case NS_sprm::LN_PPc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPc
case NS_sprm::LN_PBrcTop10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcTop10
case NS_sprm::LN_PBrcLeft10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcLeft10
case NS_sprm::LN_PBrcBottom10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBottom10
case NS_sprm::LN_PBrcRight10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcRight10
case NS_sprm::LN_PBrcBetween10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBetween10
case NS_sprm::LN_PBrcBar10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar10
case NS_sprm::LN_PDxaFromText10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText10
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWr
case NS_ooxml::LN_CT_PrBase_pBdr: //paragraph border
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
resolveSprmProps(rSprm);
break;
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: done: 0, planned: 8, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
{
//in binary format the borders are directly provided in OOXML they are inside of properties
if( IsOOXMLImport() )
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
BorderHandlerPtr pBorderHandler( new BorderHandler( true ) );
pProperties->resolve(*pBorderHandler);
PropertyIds eBorderId = PropertyIds( 0 );
PropertyIds eBorderDistId = PropertyIds( 0 );
switch( nSprmId )
{
case NS_sprm::LN_PBrcTop:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcLeft:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcRight:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcBetween:
/* WRITERFILTERSTATUS: */
//not supported
break;
default:;
}
if( eBorderId )
rContext->Insert( eBorderId, true, uno::makeAny( pBorderHandler->getBorderLine()) , true);
if(eBorderDistId)
rContext->Insert(eBorderDistId, true, uno::makeAny( pBorderHandler->getLineDistance()), true);
}
}
else
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nSprmId )
{
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: */
OSL_ENSURE( false, "TODO: inner border is not handled");
break;
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: */
default:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
}
rContext->Insert(eBorderId, true, uno::makeAny( aBorderLine ));
rContext->Insert(eBorderDistId, true, uno::makeAny( nLineDistance ));
}
}
break;
case NS_sprm::LN_PBorderTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
OSL_ENSURE( false, "TODO: border color definition");
break;
case NS_sprm::LN_PBrcBar:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar
case NS_sprm::LN_PFNoAutoHyph: // sprmPFNoAutoHyph
/* WRITERFILTERSTATUS: done: 100, planned: 1, spent: 0 */
rContext->Insert(PROP_PARA_IS_HYPHENATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWHeightAbs
case NS_sprm::LN_PDcs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDcs
case NS_sprm::LN_PShd: // sprmPShd
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 2 */
{
//contains fore color, back color and shadow percentage, results in a brush
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
CellColorHandlerPtr pCellColorHandler( new CellColorHandler );
pCellColorHandler->setParagraph();
pProperties->resolve(*pCellColorHandler);
rContext->insert( pCellColorHandler->getProperties(), true );
}
}
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaFromText
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText
case NS_sprm::LN_PFLocked:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFLocked
case NS_sprm::LN_PFWidowControl:
case NS_ooxml::LN_CT_PPrBase_widowControl:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
uno::Any aVal( uno::makeAny( sal_Int8(nIntValue ? 2 : 0 )));
rContext->Insert( PROP_PARA_WIDOWS, true, aVal );
rContext->Insert( PROP_PARA_ORPHANS, true, aVal );
}
break; // sprmPFWidowControl
case NS_sprm::LN_PRuler:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPRuler
case NS_sprm::LN_PFKinsoku:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFKinsoku
case NS_sprm::LN_PFWordWrap:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFWordWrap
case NS_sprm::LN_PFOverflowPunct: ; // sprmPFOverflowPunct - hanging punctuation
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_PARA_IS_HANGING_PUNCTUATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PFTopLinePunct:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFTopLinePunct
case NS_sprm::LN_PFAutoSpaceDE:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDE
case NS_sprm::LN_PFAutoSpaceDN:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDN
case NS_sprm::LN_PWAlignFont:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWAlignFont
case NS_sprm::LN_PFrameTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFrameTextFlow
case NS_sprm::LN_PISnapBaseLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPISnapBaseLine
case NS_sprm::LN_PAnld:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPAnld
case NS_sprm::LN_PPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPropRMark
case NS_sprm::LN_POutLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
if( m_pImpl->IsStyleSheetImport() )
{
sal_Int16 nLvl = static_cast< sal_Int16 >( nIntValue );
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetOutlineLevel( nLvl );
}
}
break; // sprmPOutLvl
case NS_sprm::LN_PFBiDi:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_WRITING_MODE, false, uno::makeAny( text::WritingMode2::RL_TB ));
rContext->Insert(PROP_PARA_ADJUST, false, uno::makeAny( style::ParagraphAdjust_RIGHT ));
break; // sprmPFBiDi
case NS_ooxml::LN_EG_SectPrContents_bidi:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
if (pSectionContext != NULL)
pSectionContext->Insert(PROP_WRITING_MODE,false, uno::makeAny( text::WritingMode2::RL_TB));
break;
case NS_sprm::LN_PFNumRMIns:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFNumRMIns
case NS_sprm::LN_PCrLf:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPCrLf
case NS_sprm::LN_PNumRM:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPNumRM
case NS_sprm::LN_PHugePapx:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPHugePapx
case NS_sprm::LN_PFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFUsePgsuSettings
case NS_sprm::LN_PFAdjustRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAdjustRight
case NS_sprm::LN_CFRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMarkDel
case NS_sprm::LN_CFRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMark
case NS_sprm::LN_CFFldVanish:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFldVanish
case NS_sprm::LN_CFSpec: // sprmCFSpec
break;
case NS_sprm::LN_CPicLocation: // sprmCPicLocation
//is being resolved on the tokenizer side
break;
case NS_sprm::LN_CIbstRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMark
case NS_sprm::LN_CDttmRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMark
case NS_sprm::LN_CFData:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFData
case NS_sprm::LN_CIdslRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMark
case NS_sprm::LN_CChs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCChs
case NS_sprm::LN_CSymbol: // sprmCSymbol
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
resolveSprmProps(rSprm); //resolves LN_FONT and LN_CHAR
break;
case NS_sprm::LN_CFOle2:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFOle2
case NS_sprm::LN_CIdCharType:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdCharType
case NS_sprm::LN_CHighlight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if(true ==( mbIsHighlightSet = getColorFromIndex(nIntValue, nColor)))
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( nColor ));
else if (mnBackgroundColor)
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( mnBackgroundColor ));
}
break; // sprmCHighlight
case NS_sprm::LN_CObjLocation:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCObjLocation
case NS_sprm::LN_CFFtcAsciSymb:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFtcAsciSymb
case NS_sprm::LN_CIstd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstd
case NS_sprm::LN_CIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstdPermute
case NS_sprm::LN_CDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDefault
case NS_sprm::LN_CPlain:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPlain
case NS_sprm::LN_CKcd:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_EMPHASIS, true, uno::makeAny ( getEmphasisValue (nIntValue)));
break; // sprmCKcd
case NS_sprm::LN_CFEmboss:// sprmCFEmboss
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi:// sprmCFBoldBi (offset 0x27 to normal bold)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalicBi:// sprmCFItalicBi (offset 0x27 to normal italic)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFBold: //sprmCFBold
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 61: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalic: //sprmCFItalic
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFStrike: //sprmCFStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5*/
case NS_sprm::LN_CFOutline: //sprmCFOutline
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFShadow: //sprmCFShadow
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFSmallCaps: //sprmCFSmallCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFCaps: //sprmCFCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFVanish: //sprmCFVanish
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFDStrike: // sprmCFDStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
{
PropertyIds ePropertyId = PROP_CHAR_WEIGHT; //initialized to prevent warning!
switch( nSprmId )
{
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
case NS_sprm::LN_CFBold: /*sprmCFBold*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId != NS_sprm::LN_CFBoldBi ? PROP_CHAR_WEIGHT : PROP_CHAR_WEIGHT_COMPLEX;
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId == 0x836 ? PROP_CHAR_POSTURE : PROP_CHAR_POSTURE_COMPLEX;
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_STRIKEOUT;
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CONTOURED;
break;
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_SHADOWED;
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CASE_MAP;
break;
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_HIDDEN;
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_RELIEF;
break;
}
//expected: 0,1,128,129
if(nIntValue != 128) //inherited from paragraph - ignore
{
if( nIntValue == 129) //inverted style sheet value
{
//get value from style sheet and invert it
sal_Int16 nStyleValue = 0;
double fDoubleValue;
uno::Any aStyleVal = m_pImpl->GetPropertyFromStyleSheet(ePropertyId);
if( !aStyleVal.hasValue() )
{
nIntValue = 0x83a == nSprmId ?
4 : 1;
}
else if(aStyleVal.getValueTypeClass() == uno::TypeClass_FLOAT )
{
//only in case of awt::FontWeight
aStyleVal >>= fDoubleValue;
nIntValue = fDoubleValue > 100. ? 0 : 1;
}
else if((aStyleVal >>= nStyleValue) ||
(nStyleValue = (sal_Int16)comphelper::getEnumAsINT32(aStyleVal)) >= 0 )
{
nIntValue = 0x83a == nSprmId ?
nStyleValue ? 0 : 4 :
nStyleValue ? 0 : 1;
}
else
{
OSL_ENSURE( false, "what type was it");
}
}
switch( nSprmId )
{
case 60:/*sprmCFBold*/
case NS_sprm::LN_CFBold: /*sprmCFBold*/
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
/* WRITERFILTERSTATUS: */
{
uno::Any aBold( uno::makeAny( nIntValue ? awt::FontWeight::BOLD : awt::FontWeight::NORMAL ) );
rContext->Insert(ePropertyId, true, aBold );
if( nSprmId != NS_sprm::LN_CFBoldBi ) // sprmCFBoldBi
rContext->Insert(PROP_CHAR_WEIGHT_ASIAN, true, aBold );
}
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
/* WRITERFILTERSTATUS: */
{
uno::Any aPosture( uno::makeAny( nIntValue ? awt::FontSlant_ITALIC : awt::FontSlant_NONE ) );
rContext->Insert( ePropertyId, true, aPosture );
if( nSprmId != NS_sprm::LN_CFItalicBi ) // sprmCFItalicBi
rContext->Insert(PROP_CHAR_POSTURE_ASIAN, true, aPosture );
}
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontStrikeout::SINGLE : awt::FontStrikeout::NONE ) );
break;
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( awt::FontStrikeout::DOUBLE ) );
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true, uno::makeAny( nIntValue ? true : false ));
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::SMALLCAPS : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::UPPERCASE : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontRelief::EMBOSSED : awt::FontRelief::NONE ));
break;
}
}
}
break;
case NS_sprm::LN_CFtcDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFtcDefault
case NS_sprm::LN_CKul: // sprmCKul
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
// Parameter: 0 = none, 1 = single, 2 = by Word,
// 3 = double, 4 = dotted, 5 = hidden
// 6 = thick, 7 = dash, 8 = dot(not used)
// 9 = dotdash 10 = dotdotdash 11 = wave
handleUnderlineType(nIntValue, rContext);
}
break;
case NS_sprm::LN_CSizePos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCSizePos
case NS_sprm::LN_CLid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCLid
case NS_sprm::LN_CIco:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if (getColorFromIndex(nIntValue, nColor))
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break; // sprmCIco
case NS_sprm::LN_CHpsBi: // sprmCHpsBi
case NS_sprm::LN_CHps: // sprmCHps
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//multiples of half points (12pt == 24)
double fVal = double(nIntValue) / 2.;
uno::Any aVal = uno::makeAny( fVal );
if( NS_sprm::LN_CHpsBi == nSprmId )
rContext->Insert( PROP_CHAR_HEIGHT_COMPLEX, true, aVal );
else
{
//Asian get the same value as Western
rContext->Insert( PROP_CHAR_HEIGHT, true, aVal );
rContext->Insert( PROP_CHAR_HEIGHT_ASIAN, true, aVal );
}
}
break;
case NS_sprm::LN_CHpsInc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc
case NS_sprm::LN_CHpsPos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
// FIXME: ww8 filter in ww8par6.cxx has a Read_SubSuperProp function
// that counts the escapement from this value and font size. So it will be
// on our TODO list
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 100;
if (nIntValue < 0)
nEscapement = -58;
else if (nIntValue > 0)
nEscapement = 58;
else /* (nIntValue == 0) */
nProp = 0;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break; // sprmCHpsPos
case NS_sprm::LN_CHpsPosAdj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsPosAdj
case NS_sprm::LN_CMajority:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority
case NS_sprm::LN_CIss: // sprmCIss
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//sub/super script 1: super, 2: sub, 0: normal
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
switch(nIntValue)
{
case 1: //super
nEscapement = 101;
break;
case 2: //sub
nEscapement = -101;
break;
case 0: nProp = 0;break; //none
}
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
case NS_sprm::LN_CHpsNew50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsNew50
case NS_sprm::LN_CHpsInc1:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc1
case 71 : //"sprmCDxaSpace"
case 96 : //"sprmCDxaSpace"
case NS_sprm::LN_CDxaSpace: // sprmCDxaSpace
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
//Kerning half point values
//TODO: there are two kerning values -
// in ww8par6.cxx NS_sprm::LN_CHpsKern is used as boolean AutoKerning
rContext->Insert(PROP_CHAR_CHAR_KERNING, true, uno::makeAny( sal_Int16(ConversionHelper::convertTwipToMM100(sal_Int16(nIntValue))) ) );
break;
case NS_sprm::LN_CHpsKern: // sprmCHpsKern auto kerning is bound to a minimum font size in Word - but not in Writer :-(
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_AUTO_KERNING, true, uno::makeAny( true ) );
break;
case NS_sprm::LN_CMajority50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority50
case NS_sprm::LN_CHpsMul:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsMul
case NS_sprm::LN_CYsri:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCYsri
case NS_sprm::LN_CRgFtc0: // sprmCRgFtc0 //ascii font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc1: // sprmCRgFtc1 //Asian font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc2: // sprmCRgFtc2 //CTL font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CFtcBi: // sprmCFtcBi //font index of a CTL font
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
FontTablePtr pFontTable = m_pImpl->GetFontTable();
if(nIntValue >= 0 && pFontTable->size() > sal_uInt32(nIntValue))
{
PropertyIds eFontName = PROP_CHAR_FONT_NAME;
PropertyIds eFontStyle = PROP_CHAR_FONT_STYLE;
PropertyIds eFontFamily = PROP_CHAR_FONT_FAMILY;
PropertyIds eFontCharSet = PROP_CHAR_FONT_CHAR_SET;
PropertyIds eFontPitch = PROP_CHAR_FONT_PITCH;
switch(nSprmId)
{
case NS_sprm::LN_CRgFtc0:
//already initialized
break;
case NS_sprm::LN_CRgFtc1:
eFontName = PROP_CHAR_FONT_NAME_ASIAN;
eFontStyle = PROP_CHAR_FONT_STYLE_ASIAN;
eFontFamily = PROP_CHAR_FONT_FAMILY_ASIAN;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_ASIAN;
eFontPitch = PROP_CHAR_FONT_PITCH_ASIAN;
break;
case NS_sprm::LN_CRgFtc2:
case NS_sprm::LN_CFtcBi:
eFontName = PROP_CHAR_FONT_NAME_COMPLEX;
eFontStyle = PROP_CHAR_FONT_STYLE_COMPLEX;
eFontFamily = PROP_CHAR_FONT_FAMILY_COMPLEX;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_COMPLEX;
eFontPitch = PROP_CHAR_FONT_PITCH_COMPLEX;
break;
}
const FontEntry::Pointer_t pFontEntry(pFontTable->getFontEntry(sal_uInt32(nIntValue)));
rContext->Insert(eFontName, true, uno::makeAny( pFontEntry->sFontName ));
// rContext->Insert(eFontStyle, uno::makeAny( pFontEntry-> ));
// rContext->Insert(eFontFamily, uno::makeAny( pFontEntry-> ));
rContext->Insert(eFontCharSet, true, uno::makeAny( (sal_Int16)pFontEntry->nTextEncoding ));
rContext->Insert(eFontPitch, true, uno::makeAny( pFontEntry->nPitchRequest ));
}
}
break;
case NS_sprm::LN_CCharScale: // sprmCCharScale
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_SCALE_WIDTH, true,
uno::makeAny( sal_Int16(nIntValue) ));
break;
case NS_sprm::LN_CFImprint: // sprmCFImprint 1 or 0
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
// FontRelief: NONE, EMBOSSED, ENGRAVED
rContext->Insert(PROP_CHAR_RELIEF, true,
uno::makeAny( nIntValue ? awt::FontRelief::ENGRAVED : awt::FontRelief::NONE ));
break;
case NS_sprm::LN_CFObj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFObj
case NS_sprm::LN_CPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPropRMark
case NS_sprm::LN_CSfxText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// The file-format has many character animations. We have only
// one, so we use it always. Suboptimal solution though.
if (nIntValue)
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( true ));
else
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( false ));
break; // sprmCSfxText
case NS_sprm::LN_CFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFBiDi
case NS_sprm::LN_CFDiacColor:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFDiacColor
case NS_sprm::LN_CIcoBi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIcoBi
case NS_sprm::LN_CDispFldRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDispFldRMark
case NS_sprm::LN_CIbstRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMarkDel
case NS_sprm::LN_CDttmRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMarkDel
case NS_sprm::LN_CBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCBrc
case NS_sprm::LN_CShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCShd
case NS_sprm::LN_CIdslRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMarkDel
case NS_sprm::LN_CFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFUsePgsuSettings
case NS_sprm::LN_CCpg:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCCpg
case NS_sprm::LN_CLidBi: // sprmCLidBi language complex
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid0_80: //sprmCRgLid0_80
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 1 */
//undocumented but interpreted as western language
case NS_sprm::LN_CRgLid0: // sprmCRgLid0 language Western
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid1: // sprmCRgLid1 language Asian
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
lang::Locale aLocale;
MsLangId::convertLanguageToLocale( (LanguageType)nIntValue, aLocale );
rContext->Insert(NS_sprm::LN_CRgLid0 == nSprmId ? PROP_CHAR_LOCALE :
NS_sprm::LN_CRgLid1 == nSprmId ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
case NS_sprm::LN_CIdctHint: // sprmCIdctHint
//list table - text offset???
break;
case NS_sprm::LN_PicBrcl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcl
case NS_sprm::LN_PicScale:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicScale
case NS_sprm::LN_PicBrcTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcTop
case NS_sprm::LN_PicBrcLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcLeft
case NS_sprm::LN_PicBrcBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcBoConversionHelper::convertTwipToMM100ttom
case NS_sprm::LN_PicBrcRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcRight
case NS_sprm::LN_ScnsPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmScnsPgn
case NS_sprm::LN_SiHeadingPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSiHeadingPgn
case NS_sprm::LN_SOlstAnm:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSOlstAnm
case 136:
case NS_sprm::LN_SDxaColWidth: // sprmSDxaColWidth
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// contains the twip width of the column as 3-byte-code
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnWidth( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case NS_sprm::LN_SDxaColSpacing: // sprmSDxaColSpacing
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnSpacing( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case 138:
case NS_sprm::LN_SFEvenlySpaced:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSFEvenlySpaced
case NS_sprm::LN_SFProtected: // sprmSFProtected
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
//todo: missing feature - unlocked sections in protected documents
break;
case NS_sprm::LN_SDmBinFirst: // sprmSDmBinFirst
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetFirstPaperBin(nIntValue);
break;
case NS_sprm::LN_SDmBinOther: // sprmSDmBinOther
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPaperBin( nIntValue );
break;
case NS_sprm::LN_SBkc: // sprmSBkc
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
/* break type
0 - No break
1 - New Colunn
2 - New page
3 - Even page
4 - odd page
*/
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBreakType( nIntValue );
break;
case 143:
case NS_sprm::LN_SFTitlePage: // sprmSFTitlePage
case NS_ooxml::LN_EG_SectPrContents_titlePg:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTitlePage( nIntValue > 0 ? true : false );//section has title page
}
break;
case 144:
case NS_sprm::LN_SCcolumns: // sprmSCcolumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//no of columns - 1
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnCount( (sal_Int16) nIntValue );
break;
case 145:
case NS_sprm::LN_SDxaColumns: // sprmSDxaColumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//column distance - default 708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnDistance( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case NS_sprm::LN_SFAutoPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFAutoPgn
case 147:
case NS_sprm::LN_SNfcPgn: // sprmSNfcPgn
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//page numbering 0 - Arab, 1 - ROMAN, 2 - roman, 3 - ABC, 4 abc
sal_Int16 nNumbering;
switch( nIntValue )
{
case 1: nNumbering = style::NumberingType::ROMAN_UPPER;
case 2: nNumbering = style::NumberingType::ROMAN_LOWER;
case 3: nNumbering = style::NumberingType::CHARS_UPPER_LETTER;
case 4: nNumbering = style::NumberingType::CHARS_LOWER_LETTER;
case 0:
default:
nNumbering = style::NumberingType::ARABIC;
}
rContext->Insert( PROP_NUMBERING_TYPE, false, uno::makeAny( nNumbering ) );
break;
case NS_sprm::LN_SDyaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDyaPgn
case NS_sprm::LN_SDxaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDxaPgn
case 150:
case NS_sprm::LN_SFPgnRestart: // sprmSFPgnRestart
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNoRestart( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFEndnote:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFEndnote
case 154:
case NS_sprm::LN_SNLnnMod:// sprmSNLnnMod
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMod( nIntValue );
break;
case 155:
case NS_sprm::LN_SDxaLnn: // sprmSDxaLnn
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetdxaLnn( nIntValue );
break;
case 152:
case NS_sprm::LN_SLnc:// sprmSLnc
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnc( nIntValue );
break;
case 160:
case NS_sprm::LN_SLnnMin: // sprmSLnnMin
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMin( nIntValue );
break;
case NS_sprm::LN_SGprfIhdt:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
//flags about header/footer sharing and footnotes?
/* ww8scan.hxx:
* WW8_HEADER_EVEN = 0x01, WW8_HEADER_ODD = 0x02, WW8_FOOTER_EVEN = 0x04,
* WW8_FOOTER_ODD = 0x08, WW8_HEADER_FIRST = 0x10, WW8_FOOTER_FIRST = 0x20
*/
// if(pSectionContext)
break; // sprmSGprfIhdt
case NS_sprm::LN_SDyaHdrTop: // sprmSDyaHdrTop
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderTop( ConversionHelper::convertTwipToMM100( nIntValue ));
break;
case NS_sprm::LN_SDyaHdrBottom: // sprmSDyaHdrBottom
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderBottom( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case 158:
case NS_sprm::LN_SLBetween: // sprmSLBetween
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSeparatorLine( nIntValue > 0 );
break;
case NS_sprm::LN_SVjc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSVjc
case 161:
case NS_sprm::LN_SPgnStart: // sprmSPgnStart
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page number
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNumber( nIntValue );
break;
case 162:
case NS_sprm::LN_SBOrientation:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//todo: the old filter assumed that a value of 2 points to double-pages layout
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetLandscape( nIntValue > 0 );
rContext->Insert( PROP_IS_LANDSCAPE , false, uno::makeAny( nIntValue > 0 ));
break; // sprmSBOrientation
case NS_sprm::LN_SBCustomize:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSBCustomize
case 165:
case NS_sprm::LN_SYaPage: // sprmSYaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page height, rounded to default values, default: 0x3dc0 twip
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_HEIGHT, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nHeight ) ) );
}
break;
case NS_sprm::LN_SXaPage: // sprmSXaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page width, rounded to default values, default 0x2fd0 twip
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_WIDTH, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nWidth ) ) );
}
break;
case 166:
case NS_sprm::LN_SDxaLeft: // sprmSDxaLeft
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//left page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetLeftMargin( nConverted );
rContext->Insert( PROP_LEFT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 167:
case NS_sprm::LN_SDxaRight: // sprmSDxaRight
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//right page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetRightMargin( nConverted );
rContext->Insert( PROP_RIGHT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 168:
case NS_sprm::LN_SDyaTop: // sprmSDyaTop
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//top page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_TOP_MARGIN, false, uno::makeAny( nConverted ) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTopMargin( nConverted );
}
break;
case 169:
case NS_sprm::LN_SDyaBottom: // sprmSDyaBottom
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//bottom page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_BOTTOM_MARGIN, false, uno::makeAny( nConverted) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBottomMargin( nConverted );
}
break;
case 170:
case NS_sprm::LN_SDzaGutter: // sprmSDzaGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// gutter is added to one of the margins of a section depending on RTL, can be placed on top either
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDzaGutter( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case NS_sprm::LN_SDmPaperReq: // sprmSDmPaperReq
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//paper code - no handled in old filter
break;
case NS_sprm::LN_SPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSPropRMark
case NS_sprm::LN_SFBiDi:// sprmSFBiDi
{
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSFBiDi( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFFacingCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFFacingCol
case NS_sprm::LN_SFRTLGutter: // sprmSFRTLGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetGutterRTL( nIntValue > 0 );
}
break;
case NS_sprm::LN_SBrcTop: // sprmSBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcLeft: // sprmSBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcBottom: // sprmSBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcRight: // sprmSBrcRight
/* WRITERFILTERSTATUS: Sectiondone: 100, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
static const BorderPosition aPositions[4] =
{
BORDER_TOP,
BORDER_LEFT,
BORDER_BOTTOM,
BORDER_RIGHT
};
pSectionContext->SetBorder( aPositions[nSprmId - NS_sprm::LN_SBrcTop], nLineDistance, aBorderLine );
}
}
break;
case NS_sprm::LN_SPgbProp: // sprmSPgbProp
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->ApplyBorderToPageStyles( m_pImpl->GetPageStyles(), m_pImpl->GetTextFactory(), nIntValue );
}
}
break;
case NS_sprm::LN_SDxtCharSpace:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDxtCharSpace( nIntValue );
}
}
break; // sprmSDxtCharSpace
case NS_sprm::LN_SDyaLinePitch: // sprmSDyaLinePitch
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//see SwWW8ImplReader::SetDocumentGrid
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetGridLinePitch( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case 0x703a: //undocumented, grid related?
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE( false, "TODO: not handled yet"); //nIntValue like 0x008a2373 ?
break;
case NS_sprm::LN_SClm:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
sal_Int16 nGridType = text::TextGridMode::NONE;
switch( nIntValue )
{
case 0:
nGridType = text::TextGridMode::NONE;
break;
case 3:
//Text snaps to char grid, this doesn't make a lot of sense to
//me. This is closer than LINES_CHARS
nGridType = text::TextGridMode::LINES;
break;
case 1:
nGridType = text::TextGridMode::LINES_AND_CHARS;
break;
case 2:
nGridType = text::TextGridMode::LINES;
break;
default:;
}
rContext->Insert( PROP_GRID_MODE, false, uno::makeAny( nGridType ) );
//Seems to force this behaviour in word ?
if(nGridType != text::TextGridMode::NONE)
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_EXTERNAL_LEADING ),
uno::makeAny( true ) );
}
break; // sprmSClm
case NS_sprm::LN_STextFlow:
case NS_ooxml::LN_EG_SectPrContents_textDirection:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
/* 0 HoriLR 1 Vert TR 2 Vert TR 3 Vert TT 4 HoriLT
only 0 and 1 can be imported correctly
*/
sal_Int16 nDirection = text::WritingMode_LR_TB;
switch( nIntValue )
{
case 0:
case 4:
nDirection = text::WritingMode_LR_TB;
break;
case 1:
case 2:
case 3:
nDirection = text::WritingMode_TB_RL;
break;
default:;
}
PropertyMap * pTargetContext = rContext.get();
if (pSectionContext != NULL &&
nSprmId == NS_ooxml::LN_EG_SectPrContents_textDirection)
{
pTargetContext = pSectionContext;
}
pTargetContext->Insert(PROP_WRITING_MODE, false, uno::makeAny( nDirection ) );
}
break; // sprmSTextFlow
case NS_sprm::LN_TJc: // sprmTJc
case NS_sprm::LN_TDxaLeft:
case NS_sprm::LN_TDxaGapHalf:
case NS_sprm::LN_TFCantSplit:
case NS_sprm::LN_TTableHeader:
case NS_sprm::LN_TTableBorders: // sprmTTableBorders
{
OSL_ENSURE( false, "table propeties should be handled by the table manager");
}
break;
case NS_sprm::LN_TDefTable10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable10
case NS_sprm::LN_TDyaRowHeight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDyaRowHeight
case NS_sprm::LN_TDefTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable
case NS_sprm::LN_TDefTableShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTableShd
case NS_sprm::LN_TTlp:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTlp
case NS_sprm::LN_TFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTFBiDi
case NS_sprm::LN_THTMLProps:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTHTMLProps
case NS_sprm::LN_TSetBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc
case NS_sprm::LN_TInsert:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTInsert
case NS_sprm::LN_TDelete:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDelete
case NS_sprm::LN_TDxaCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDxaCol
case NS_sprm::LN_TMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTMerge
case NS_sprm::LN_TSplit:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSplit
case NS_sprm::LN_TSetBrc10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc10
case 164: // sprmTSetShd
case NS_sprm::LN_TSetShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShd
case NS_sprm::LN_TSetShdOdd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShdOdd
case NS_sprm::LN_TTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTextFlow
case NS_sprm::LN_TDiagLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDiagLine
case NS_sprm::LN_TVertMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertMerge
case NS_sprm::LN_TVertAlign:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertAlign
// the following are not part of the official documentation
case 0x6870: //TxtForeColor
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//contains a color as 0xTTRRGGBB while SO uses 0xTTRRGGBB
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x4874:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //seems to be a language id for Asian text - undocumented
case 0x6877: //underlining color
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
rContext->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x6815:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case NS_sprm::LN_CIndrsid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x6467:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xF617:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xd634: // sprmTNewSpacing - table spacing ( see WW8TabBandDesc::ProcessSpacing() )
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break;
case NS_sprm::LN_TTRLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x4888:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0x6887:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//properties of list levels - undocumented
break;
case 0xd234:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd235:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd236:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd237:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;//undocumented section properties
case NS_sprm::LN_CEastAsianLayout:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_CT_Tabs_tab:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
m_pImpl->IncorporateTabStop(m_pImpl->m_aCurrentTabStop);
m_pImpl->m_aCurrentTabStop = DeletableTabStop();
break;
case NS_ooxml::LN_CT_PPrBase_tabs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
// Initialize tab stop vector from style sheet
if( !m_pImpl->IsStyleSheetImport() )
{
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
}
resolveSprmProps(rSprm);
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case NS_ooxml::LN_CT_PPr_sectPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_color:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_rFonts:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_bdr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_eastAsianLayout:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_u:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_lang:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_spacing:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_ind:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_RPrDefault_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrDefault_pPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_pPrDefault:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_rPrDefault:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_pPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPr_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_numPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_footnotePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_SectPrContents_endnotePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetInFootnoteProperties( NS_ooxml::LN_EG_SectPrContents_footnotePr == nSprmId );
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_lnNumType:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
aSettings.bIsOn = true;
m_pImpl->SetLineNumberSettings( aSettings );
//apply settings at XLineNumberingProperties
try
{
uno::Reference< text::XLineNumberingProperties > xLineNumberingProperties( m_pImpl->GetTextDocument(), uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySet > xLineNumberingPropSet = xLineNumberingProperties->getLineNumberingProperties();
PropertyNameSupplier& rNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_IS_ON ), uno::makeAny(true) );
if( aSettings.nInterval )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_INTERVAL ), uno::makeAny((sal_Int16)aSettings.nInterval) );
if( aSettings.nDistance )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_DISTANCE ), uno::makeAny(aSettings.nDistance) );
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_RESTART_AT_EACH_PAGE ), uno::makeAny(aSettings.bRestartAtEachPage) );
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_CT_PPrBase_framePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pContext.get() )
{
ParagraphPropertyMap* pParaContext = dynamic_cast< ParagraphPropertyMap* >( pContext.get() );
pParaContext->SetFrameMode();
}
else
{
//TODO: What about style sheet import of frame properties
}
resolveSprmProps(rSprm);
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgSz:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = 0;
{
PaperInfo aLetter(PAPER_LETTER);
CT_PageSz.w = aLetter.getWidth();
CT_PageSz.h = aLetter.getHeight();
}
CT_PageSz.orient = false;
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->Insert( PROP_HEIGHT, false, uno::makeAny( CT_PageSz.h ) );
pSectionContext->Insert( PROP_IS_LANDSCAPE, false, uno::makeAny( CT_PageSz.orient ));
pSectionContext->Insert( PROP_WIDTH, false, uno::makeAny( CT_PageSz.w ) );
pSectionContext->SetLandscape( CT_PageSz.orient );
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgMar:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->InitPageMargins();
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
const _PageMar& rPageMar = m_pImpl->GetPageMargins();
pSectionContext->SetTopMargin( rPageMar.top );
pSectionContext->SetRightMargin( rPageMar.right );
pSectionContext->SetBottomMargin( rPageMar.bottom );
pSectionContext->SetLeftMargin( rPageMar.left );
pSectionContext->SetHeaderTop( rPageMar.header );
pSectionContext->SetHeaderBottom( rPageMar.footer );
}
break;
case NS_ooxml::LN_EG_SectPrContents_cols:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
SectionColumnHandlerPtr pSectHdl( new SectionColumnHandler );
pProperties->resolve(*pSectHdl);
if(pSectionContext)
{
if( pSectHdl->IsEqualWidth() )
{
pSectionContext->SetEvenlySpaced( true );
pSectionContext->SetColumnCount( (sal_Int16) (pSectHdl->GetNum() - 1) );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( !pSectHdl->GetColumns().empty() )
{
pSectionContext->SetEvenlySpaced( false );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetColumnCount( (sal_Int16)(pSectHdl->GetColumns().size() -1));
std::vector<_Column>::const_iterator tmpIter = pSectHdl->GetColumns().begin();
for (; tmpIter != pSectHdl->GetColumns().end(); tmpIter++)
{
pSectionContext->AppendColumnWidth( tmpIter->nWidth );
if ((tmpIter != pSectHdl->GetColumns().end() - 1) || (tmpIter->nSpace > 0))
pSectionContext->AppendColumnSpacing( tmpIter->nSpace );
}
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( pSectHdl->GetNum() > 0 )
{
pSectionContext->SetColumnCount( (sal_Int16)pSectHdl->GetNum() - 1 );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
}
}
}
}
break;
case NS_ooxml::LN_EG_SectPrContents_docGrid:
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_pgBorders:
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get( ) && pSectionContext )
{
PageBordersHandlerPtr pHandler( new PageBordersHandler );
pProperties->resolve( *pHandler );
// Set the borders to the context and apply them to the styles
pHandler->SetBorders( pSectionContext );
pSectionContext->SetBorderParams( pHandler->GetDisplayOffset( ) );
}
}
break;
case NS_ooxml::LN_CT_PPrBase_pStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
m_pImpl->SetCurrentParaStyleId( sStringValue );
StyleSheetTablePtr pStyleTable = m_pImpl->GetStyleSheetTable();
const ::rtl::OUString sConvertedStyleName = pStyleTable->ConvertStyleName( sStringValue, true );
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sConvertedStyleName ));
const StyleSheetEntryPtr pEntry = pStyleTable->FindStyleSheetByISTD(sStringValue);
//apply numbering to paragraph if it was set at the style
OSL_ENSURE( pEntry.get(), "no style sheet found" );
const StyleSheetPropertyMap* pStyleSheetProperties = dynamic_cast<const StyleSheetPropertyMap*>(pEntry ? pEntry->pProperties.get() : 0);
if( pStyleSheetProperties && pStyleSheetProperties->GetListId() >= 0 )
rContext->Insert( PROP_NUMBERING_STYLE_NAME, true, uno::makeAny(
m_pImpl->GetListTable( )->GetStyleName( pStyleSheetProperties->GetListId( ) ) ), false);
if( pStyleSheetProperties && pStyleSheetProperties->GetListLevel() >= 0 )
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny(pStyleSheetProperties->GetListLevel()), false);
}
break;
case NS_ooxml::LN_EG_RPrBase_rStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
rtl::OUString sConvertedName( m_pImpl->GetStyleSheetTable()->ConvertStyleName( sStringValue, true ) );
// First check if the style exists in the document.
StyleSheetEntryPtr pEntry = m_pImpl->GetStyleSheetTable( )->FindStyleSheetByStyleName( sConvertedName );
bool bExists = pEntry.get( ) && ( pEntry->nStyleTypeCode == STYLE_TYPE_CHAR );
// Add the property if the style exists
if ( bExists && m_pImpl->GetTopContext() )
m_pImpl->GetTopContext()->Insert( PROP_CHAR_STYLE_NAME, true, uno::makeAny( sConvertedName ) );
}
break;
case NS_ooxml::LN_CT_TblPrBase_tblCellMar: //cell margins
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);//contains LN_CT_TblCellMar_top, LN_CT_TblCellMar_left, LN_CT_TblCellMar_bottom, LN_CT_TblCellMar_right
}
break;
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
MeasureHandlerPtr pMeasureHandler( new MeasureHandler );
pProperties->resolve(*pMeasureHandler);
sal_Int32 nMeasureValue = pMeasureHandler->getMeasureValue();
PropertyIds eId = META_PROP_CELL_MAR_TOP;
switch(nSprmId)
{
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: */
break;
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_LEFT;
break;
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_BOTTOM;
break;
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_RIGHT;
break;
default:;
}
rContext->Insert( eId, false, uno::makeAny(nMeasureValue), false);
}
}
break;
case NS_sprm::LN_CFNoProof: //0x875 no grammar and spell checking, unsupported
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_ooxml::LN_anchor_anchor: // at_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_inline_inline: // as_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
GraphicImportType eGraphicType =
(NS_ooxml::LN_anchor_anchor ==
sal::static_int_cast<Id>(nSprmId)) ?
IMPORT_AS_DETECTED_ANCHOR :
IMPORT_AS_DETECTED_INLINE;
GraphicImportPtr pGraphicImport =
m_pImpl->GetGraphicImport(eGraphicType);
pProperties->resolve(*pGraphicImport);
m_pImpl->ImportGraphic(pProperties, eGraphicType);
if( !pGraphicImport->IsGraphic() )
{
m_pImpl->ResetGraphicImport();
// todo: It's a shape, now start shape import
}
}
}
break;
case NS_ooxml::LN_EG_RPrBase_vertAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
if( sStringValue.equalsAscii( "superscript" ))
nEscapement = 101;
else if( sStringValue.equalsAscii( "subscript" ))
nEscapement = -101;
else
nProp = 100;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
// case NS_ooxml::LN_CT_FtnEdn_type
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnEdn_id
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_EG_FtnEdnNumProps_numRestart
case NS_ooxml::LN_CT_FtnProps_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnotes in word can be at page end or beneath text - writer supports only the first
//endnotes in word can be at section end or document end - writer supports only the latter
// -> so this property can be ignored
break;
case NS_ooxml::LN_EG_FtnEdnNumProps_numStart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_FtnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_EdnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
try
{
uno::Reference< beans::XPropertySet > xFtnEdnSettings;
if( m_pImpl->IsInFootnoteProperties() )
{
uno::Reference< text::XFootnotesSupplier> xFootnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xFootnotesSupplier->getFootnoteSettings();
}
else
{
uno::Reference< text::XEndnotesSupplier> xEndnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xEndnotesSupplier->getEndnoteSettings();
}
if( NS_ooxml::LN_EG_FtnEdnNumProps_numStart == nSprmId )
{
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_START_AT),
uno::makeAny( sal_Int16( nIntValue - 1 )));
}
else
{
sal_Int16 nNumType = ConversionHelper::ConvertNumberingType( nIntValue );
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_NUMBERING_TYPE),
uno::makeAny( nNumType ));
}
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_paratrackchange:
m_pImpl->StartParaChange( );
case NS_ooxml::LN_trackchange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
case NS_ooxml::LN_EG_RPrContent_rPrChange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
{
m_pImpl->AddNewRedline( );
resolveSprmProps( rSprm );
// now the properties author, date and id should be available
sal_Int32 nToken = m_pImpl->GetCurrentRedlineToken();
switch( nToken & 0xffff )
{
case ooxml::OOXML_mod :
case ooxml::OOXML_ins :
case ooxml::OOXML_del : break;
default: OSL_ENSURE( false, "redline token other than mod, ins or del" );
}
m_pImpl->EndParaChange( );
}
break;
case NS_ooxml::LN_CT_RPrChange_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
break;
/* WRITERFILTERSTATUS: done: 0, planned: 4, spent: 0 */
case NS_ooxml::LN_object:
{
#if DEBUG
clog << "DomainMapper: LN_object" << endl;
#endif
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get( ) )
{
OLEHandlerPtr pOLEHandler( new OLEHandler );
pProperties->resolve(*pOLEHandler);
if ( pOLEHandler->isOLEObject( ) )
{
::rtl::OUString sStreamName = pOLEHandler->copyOLEOStream( m_pImpl->GetTextDocument() );
if( sStreamName.getLength() )
{
m_pImpl->appendOLE( sStreamName, pOLEHandler );
}
}
}
}
break;
// case NS_ooxml::LN_CT_EdnProps_pos
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnProps_numFmt
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnDocProps_footnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnDocProps_endnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//break;
case NS_ooxml::LN_EG_HdrFtrReferences_headerReference: // header reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_HdrFtrReferences_footerReference: // footer reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_EG_RPrBase_snapToGrid: // "Use document grid settings for inter-paragraph spacing"
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_sprm::LN_PContextualSpacing:
//TODO: determines whether top/bottom paragraph spacing is added if equal styles are following - unsupported
break;
case NS_ooxml::LN_EG_SectPrContents_formProt: //section protection, only form editing is enabled - unsupported
case NS_ooxml::LN_EG_SectPrContents_vAlign:
case NS_ooxml::LN_EG_RPrBase_fitText:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_ooxml::LN_CT_Lvl_pStyle:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//TODO: numbering style should apply current numbering level - not yet supported
break;
default:
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("unhandled");
dmapper_logger->attribute("id", nSprmId);
dmapper_logger->endElement("unhandled");
#endif
}
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("sprm");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::entry(int /*pos*/,
writerfilter::Reference<Properties>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("entry");
#endif
ref->resolve(*this);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("entry");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::data(const sal_uInt8* /*buf*/, size_t /*len*/,
writerfilter::Reference<Properties>::Pointer_t /*ref*/)
{
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startSectionGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("section");
#endif
m_pImpl->PushProperties(CONTEXT_SECTION);
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endSectionGroup()
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_SECTION);
SectionPropertyMap* pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->CloseSectionGroup( *m_pImpl );
m_pImpl->PopProperties(CONTEXT_SECTION);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("section");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startParagraphGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("paragraph");
#endif
m_pImpl->getTableManager().startParagraphGroup();
m_pImpl->PushProperties(CONTEXT_PARAGRAPH);
static ::rtl::OUString sDefault( ::rtl::OUString::createFromAscii("Standard") );
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sDefault ) );
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
}
m_pImpl->clearDeferredBreaks();
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endParagraphGroup()
{
//handle unprocessed deferred breaks
PropertyMapPtr pParaProperties = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pParaProperties->hasEmptyPropertyValues() )
{
PropertyMap::const_iterator aIter = pParaProperties->find(PropertyDefinition( PROP_BREAK_TYPE , false ) );
if( aIter != pParaProperties->end() )
{
style::BreakType eType;
aIter->second >>= eType;
bool bPage = false;
bool bColumn = false;
if( eType == style::BreakType_PAGE_BEFORE )
bPage = true;
else if( eType == style::BreakType_COLUMN_BEFORE )
bColumn = true;
if( bPage || bColumn )
{
try
{
uno::Reference< beans::XPropertySet > xRangeProperties( m_pImpl->GetTopTextAppend()->getEnd(), uno::UNO_QUERY_THROW );
xRangeProperties->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_BREAK_TYPE),
uno::makeAny( bPage ? style::BreakType_PAGE_BEFORE : style::BreakType_COLUMN_BEFORE));
}
catch( const uno::Exception& )
{
}
}
}
}
m_pImpl->PopProperties(CONTEXT_PARAGRAPH);
m_pImpl->getTableManager().endParagraphGroup();
//frame conversion has to be executed after table conversion
m_pImpl->ExecuteFrameConversion();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("paragraph");
#endif
}
void DomainMapper::startShape( uno::Reference< drawing::XShape > xShape )
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("shape");
#endif
m_pImpl->PushShapeContext( xShape );
}
void DomainMapper::endShape( )
{
m_pImpl->PopShapeContext( );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("shape");
#endif
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushStyleSheetProperties( PropertyMapPtr pStyleProperties, bool bAffectTableMngr )
{
m_pImpl->PushStyleProperties( pStyleProperties );
if ( bAffectTableMngr )
m_pImpl->getTableManager( ).SetStyleProperties( pStyleProperties );
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopStyleSheetProperties( bool bAffectTableMngr )
{
m_pImpl->PopProperties( CONTEXT_STYLESHEET );
if ( bAffectTableMngr )
{
PropertyMapPtr emptyPtr;
m_pImpl->getTableManager( ).SetStyleProperties( emptyPtr );
}
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushListProperties( ::boost::shared_ptr<PropertyMap> pListProperties )
{
m_pImpl->PushListProperties( pListProperties );
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopListProperties()
{
m_pImpl->PopProperties( CONTEXT_LIST );
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startCharacterGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("charactergroup");
#endif
m_pImpl->PushProperties(CONTEXT_CHARACTER);
DomainMapperTableManager& rTableManager = m_pImpl->getTableManager();
if( rTableManager.getTableStyleName().getLength() )
{
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
rTableManager.CopyTextProperties(pTopContext, m_pImpl->GetStyleSheetTable());
}
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endCharacterGroup()
{
m_pImpl->PopProperties(CONTEXT_CHARACTER);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("charactergroup");
#endif
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::text(const sal_uInt8 * data_, size_t len)
{
//TODO: Determine the right text encoding (FIB?)
::rtl::OUString sText( (const sal_Char*) data_, len, RTL_TEXTENCODING_MS_1252 );
try
{
if(len == 1)
{
switch(*data_)
{
case 0x02: return; //footnote character
case 0x0c: //page break
m_pImpl->deferBreak(PAGE_BREAK);
return;
case 0x0e: //column break
m_pImpl->deferBreak(COLUMN_BREAK);
return;
case 0x07:
m_pImpl->getTableManager().text(data_, len);
case 0x0d:
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
return;
case 0x13:
m_pImpl->PushFieldContext();
return;
case 0x14:
// delimiter not necessarily available
// appears only if field contains further content
m_pImpl->CloseFieldCommand();
return;
case 0x15: /* end of field */
m_pImpl->PopFieldContext();
return;
default:
break;
}
}
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
if( pContext->GetFootnote().is() && m_pImpl->IsCustomFtnMark() )
{
pContext->GetFootnote()->setLabel( sText );
m_pImpl->SetCustomFtnMark( false );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
{
//--> debug
//sal_uInt32 nSize = pContext->size();
//<--
if (pContext == NULL)
pContext.reset(new PropertyMap());
m_pImpl->appendTextPortion( sText, pContext );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("text");
dmapper_logger->chars(sText);
dmapper_logger->endElement("text");
#endif
}
}
catch( const uno::RuntimeException& )
{
std::clog << __FILE__ << "(l" << __LINE__ << ")" << std::endl;
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::utext(const sal_uInt8 * data_, size_t len)
{
OUString sText;
OUStringBuffer aBuffer = OUStringBuffer(len);
aBuffer.append( (const sal_Unicode *) data_, len);
sText = aBuffer.makeStringAndClear();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("utext");
dmapper_logger->chars(sText);
dmapper_logger->endElement("utext");
#endif
try
{
m_pImpl->getTableManager().utext(data_, len);
if(len == 1 && ((*data_) == 0x0d || (*data_) == 0x07))
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
else
{
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
/* doesn't seem to be working
if( pContext->GetFootnote().is() )
{
//todo: the check for 0x0a is a hack!
if( *data_ != 0x0a && !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else */
if( pContext && pContext->GetFootnote().is() )
{
if( !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
{
if (pContext == NULL)
pContext.reset(new PropertyMap());
m_pImpl->appendTextPortion( sText, pContext );
}
}
}
catch( const uno::RuntimeException& )
{
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::props(writerfilter::Reference<Properties>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("props");
#endif
string sType = ref->getType();
if( sType == "PICF" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_GRAPHIC);
}
else if( sType == "FSPA" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_SHAPE);
}
else
ref->resolve(*this);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("props");
#endif
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("table");
dmapper_logger->attribute("id", (*QNameToString::Instance())(name));
#endif
// printf ( "DomainMapper::table(0x%.4x)\n", (unsigned int)name);
m_pImpl->SetAnyTableImport(true);
/* WRITERFILTERSTATUS: table: attributedata */
switch(name)
{
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// create a font table object that listens to the attributes
// each entry call inserts a new font entry
ref->resolve( *m_pImpl->GetFontTable() );
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//same as above to import style sheets
m_pImpl->SetStyleSheetImport( true );
ref->resolve( *m_pImpl->GetStyleSheetTable() );
m_pImpl->GetStyleSheetTable()->ApplyStyleSheets(m_pImpl->GetFontTable());
m_pImpl->SetStyleSheetImport( false );
break;
case NS_ooxml::LN_NUMBERING:
case NS_rtf::LN_LISTTABLE:
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//the same for list tables
ref->resolve( *m_pImpl->GetListTable() );
m_pImpl->GetListTable( )->CreateNumberingRules( );
}
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
ref->resolve( *m_pImpl->GetLFOTable() );
break;
case NS_ooxml::LN_THEMETABLE:
ref->resolve ( *m_pImpl->GetThemeTable() );
break;
case NS_ooxml::LN_settings_settings:
ref->resolve ( *m_pImpl->GetSettingsTable() );
m_pImpl->ApplySettingsTable();
break;
default:
OSL_ENSURE( false, "which table is to be filled here?");
}
m_pImpl->SetAnyTableImport(false);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("table");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::substream(Id rName, ::writerfilter::Reference<Stream>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("substream");
#endif
m_pImpl->getTableManager().startLevel();
//->debug
//string sName = (*QNameToString::Instance())(rName);
//--<debug
//import of page header/footer
/* WRITERFILTERSTATUS: table: attributedata */
switch( rName )
{
case NS_rtf::LN_headerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_headerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_footerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PushFootOrEndnote( NS_rtf::LN_footnote == rName );
break;
case NS_rtf::LN_annotation :
m_pImpl->PushAnnotation();
break;
}
ref->resolve(*this);
switch( rName )
{
case NS_rtf::LN_headerl:
case NS_rtf::LN_headerr:
case NS_rtf::LN_headerf:
case NS_rtf::LN_footerl:
case NS_rtf::LN_footerr:
case NS_rtf::LN_footerf:
m_pImpl->PopPageHeaderFooter();
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PopFootOrEndnote();
break;
case NS_rtf::LN_annotation :
m_pImpl->PopAnnotation();
break;
}
m_pImpl->getTableManager().endLevel();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("substream");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::info(const string & /*info_*/)
{
}
void DomainMapper::handleUnderlineType(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext)
{
sal_Int16 eUnderline = awt::FontUnderline::NONE;
switch(nIntValue)
{
case 0: eUnderline = awt::FontUnderline::NONE; break;
case 2: pContext->Insert(PROP_CHAR_WORD_MODE, true, uno::makeAny( true ) ); // TODO: how to get rid of it?
case 1: eUnderline = awt::FontUnderline::SINGLE; break;
case 3: eUnderline = awt::FontUnderline::DOUBLE; break;
case 4: eUnderline = awt::FontUnderline::DOTTED; break;
case 7: eUnderline = awt::FontUnderline::DASH; break;
case 9: eUnderline = awt::FontUnderline::DASHDOT; break;
case 10:eUnderline = awt::FontUnderline::DASHDOTDOT; break;
case 6: eUnderline = awt::FontUnderline::BOLD; break;
case 11:eUnderline = awt::FontUnderline::WAVE; break;
case 20:eUnderline = awt::FontUnderline::BOLDDOTTED; break;
case 23:eUnderline = awt::FontUnderline::BOLDDASH; break;
case 39:eUnderline = awt::FontUnderline::LONGDASH; break;
case 55:eUnderline = awt::FontUnderline::BOLDLONGDASH; break;
case 25:eUnderline = awt::FontUnderline::BOLDDASHDOT; break;
case 26:eUnderline = awt::FontUnderline::BOLDDASHDOTDOT;break;
case 27:eUnderline = awt::FontUnderline::BOLDWAVE; break;
case 43:eUnderline = awt::FontUnderline::DOUBLEWAVE; break;
default: ;
}
pContext->Insert(PROP_CHAR_UNDERLINE, true, uno::makeAny( eUnderline ) );
}
void DomainMapper::handleParaJustification(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext, const bool bExchangeLeftRight)
{
sal_Int16 nAdjust = 0;
sal_Int16 nLastLineAdjust = 0;
switch(nIntValue)
{
case 1:
nAdjust = style::ParagraphAdjust_CENTER;
break;
case 2:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_LEFT : style::ParagraphAdjust_RIGHT);
break;
case 4:
nLastLineAdjust = style::ParagraphAdjust_BLOCK;
//no break;
case 3:
nAdjust = style::ParagraphAdjust_BLOCK;
break;
case 0:
default:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_RIGHT : style::ParagraphAdjust_LEFT);
break;
}
pContext->Insert( PROP_PARA_ADJUST, true, uno::makeAny( nAdjust ) );
pContext->Insert( PROP_PARA_LAST_LINE_ADJUST, true, uno::makeAny( nLastLineAdjust ) );
}
bool DomainMapper::getColorFromIndex(const sal_Int32 nIndex, sal_Int32 &nColor)
{
nColor = 0;
if ((nIndex < 1) || (nIndex > 16))
return false;
switch (nIndex)
{
case 1: nColor=0x000000; break; //black
case 2: nColor=0x0000ff; break; //blue
case 3: nColor=0x00ffff; break; //cyan
case 4: nColor=0x00ff00; break; //green
case 5: nColor=0xff00ff; break; //magenta
case 6: nColor=0xff0000; break; //red
case 7: nColor=0xffff00; break; //yellow
case 8: nColor=0xffffff; break; //white
case 9: nColor=0x000080; break;//dark blue
case 10: nColor=0x008080; break; //dark cyan
case 11: nColor=0x008000; break; //dark green
case 12: nColor=0x800080; break; //dark magenta
case 13: nColor=0x800000; break; //dark red
case 14: nColor=0x808000; break; //dark yellow
case 15: nColor=0x808080; break; //dark gray
case 16: nColor=0xC0C0C0; break; //light gray
default:
return false;
}
return true;
}
sal_Int16 DomainMapper::getEmphasisValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1:
return com::sun::star::text::FontEmphasis::DOT_ABOVE;
case 2:
return com::sun::star::text::FontEmphasis::ACCENT_ABOVE;
case 3:
return com::sun::star::text::FontEmphasis::CIRCLE_ABOVE;
case 4:
return com::sun::star::text::FontEmphasis::DOT_BELOW;
default:
return com::sun::star::text::FontEmphasis::NONE;
}
}
rtl::OUString DomainMapper::getBracketStringFromEnum(const sal_Int32 nIntValue, const bool bIsPrefix)
{
switch(nIntValue)
{
case 1:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "(" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ")" ));
case 2:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "[" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "]" ));
case 3:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "<" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ">" ));
case 4:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "{" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "}" ));
case 0:
default:
return rtl::OUString();
}
}
void DomainMapper::resolveSprmProps(Sprm & rSprm)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
pProperties->resolve(*this);
}
void DomainMapper::resolveAttributeProperties(Value & val)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
pProperties->resolve(*this);
}
com::sun::star::style::TabAlign DomainMapper::getTabAlignFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 0:
case 4: // bar not supported
return com::sun::star::style::TabAlign_LEFT;
case 1:
return com::sun::star::style::TabAlign_CENTER;
case 2:
return com::sun::star::style::TabAlign_RIGHT;
case 3:
return com::sun::star::style::TabAlign_DECIMAL;
default:
return com::sun::star::style::TabAlign_DEFAULT;
}
return com::sun::star::style::TabAlign_LEFT;
}
sal_Unicode DomainMapper::getFillCharFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1: // dot
return sal_Unicode(0x002e);
case 2: // hyphen
return sal_Unicode(0x002d);
case 3: // underscore
case 4: // heavy FIXME ???
return sal_Unicode(0x005f);
case NS_ooxml::LN_Value_ST_TabTlc_middleDot: // middleDot
return sal_Unicode(0x00b7);
case 0: // none
default:
return sal_Unicode(0x0020); // blank space
}
}
/*-- 18.07.2007 14:59:00---------------------------------------------------
-----------------------------------------------------------------------*/
bool DomainMapper::IsOOXMLImport() const
{
return m_pImpl->IsOOXMLImport();
}
/*-- 18.07.2007 16:03:14---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference < lang::XMultiServiceFactory > DomainMapper::GetTextFactory() const
{
return m_pImpl->GetTextFactory();
}
/*-- 12.11.2007 10:41:01---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::AddListIDToLFOTable( sal_Int32 nAbstractNumId )
{
m_pImpl->GetLFOTable()->AddListID( nAbstractNumId );
}
/*-- 31.01.2008 18:19:44---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference< text::XTextRange > DomainMapper::GetCurrentTextRange()
{
return m_pImpl->GetTopTextAppend()->getEnd();
}
/*-- 05.02.2008 10:26:26---------------------------------------------------
-----------------------------------------------------------------------*/
::rtl::OUString DomainMapper::getOrCreateCharStyle( PropertyValueVector_t& rCharProperties )
{
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
return pStyleSheets->getOrCreateCharStyle( rCharProperties );
}
} //namespace dmapper
} //namespace writerfilter
writerfilter08: shading not supported on characters in ODT
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: DomainMapper.cxx,v $
*
* $Revision: 1.69 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include "PageBordersHandler.hxx"
#include <dmapper/DomainMapper.hxx>
#include <DomainMapper_Impl.hxx>
#include <ConversionHelper.hxx>
#include <ThemeTable.hxx>
#include <ModelEventListener.hxx>
#include <MeasureHandler.hxx>
#include <OLEHandler.hxx>
#include <i18npool/mslangid.hxx>
#include <i18npool/paper.hxx>
#include <ooxml/OOXMLFastTokens.hxx>
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#include <com/sun/star/document/XOOXMLDocumentPropertiesImporter.hpp>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/RelOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/WrapTextMode.hpp>
#include <com/sun/star/text/SizeType.hpp>
#include <com/sun/star/text/XEndnotesSupplier.hpp>
#include <com/sun/star/text/XFootnotesSupplier.hpp>
#include <com/sun/star/text/XLineNumberingProperties.hpp>
#include <com/sun/star/text/XTextDocument.hpp>
#include <com/sun/star/text/XTextCursor.hpp>
#include <com/sun/star/text/XTextPortionAppend.hpp>
#include <com/sun/star/text/XParagraphAppend.hpp>
#include <com/sun/star/text/FontEmphasis.hpp>
#include <com/sun/star/awt/FontRelief.hpp>
#include <com/sun/star/awt/FontWeight.hpp>
#include <com/sun/star/awt/FontUnderline.hpp>
#include <com/sun/star/awt/FontStrikeout.hpp>
#include <com/sun/star/awt/FontSlant.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/drawing/XShape.hpp>
#include <com/sun/star/document/XEventBroadcaster.hpp>
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/style/BreakType.hpp>
#include <com/sun/star/style/CaseMap.hpp>
#include <com/sun/star/style/LineSpacing.hpp>
#include <com/sun/star/style/LineSpacingMode.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <com/sun/star/text/TextGridMode.hpp>
#include <com/sun/star/text/XDocumentIndexesSupplier.hpp>
#include <com/sun/star/text/WritingMode.hpp>
#include <com/sun/star/text/WritingMode2.hpp>
#include <com/sun/star/text/XFootnote.hpp>
#include <com/sun/star/style/NumberingType.hpp>
#include <comphelper/types.hxx>
#include <comphelper/storagehelper.hxx>
#include <rtl/ustrbuf.hxx>
#include <boost/shared_ptr.hpp>
#include <com/sun/star/uno/Any.hxx>
#include <tools/color.hxx>
#include <BorderHandler.hxx>
#include <CellColorHandler.hxx>
#include <SectionColumnHandler.hxx>
#include <vector>
#include <iostream>
#ifdef DEBUG_DOMAINMAPPER
#include <resourcemodel/QNameToString.hxx>
#include <resourcemodel/util.hxx>
#include <resourcemodel/TagLogger.hxx>
#endif
#if OSL_DEBUG_LEVEL > 0
#include <resourcemodel/QNameToString.hxx>
#endif
using namespace ::com::sun::star;
using namespace ::rtl;
namespace writerfilter {
namespace dmapper{
#ifdef DEBUG_DOMAINMAPPER
TagLogger::Pointer_t dmapper_logger(TagLogger::getInstance("DOMAINMAPPER"));
#endif
/* ---- Fridrich's mess begins here ---- */
struct _PageSz
{
sal_Int32 code;
sal_Int32 h;
bool orient;
sal_Int32 w;
} CT_PageSz;
/* ---- Fridrich's mess (hopefully) ends here ---- */
/*-- 09.06.2006 09:52:11---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::DomainMapper( const uno::Reference< uno::XComponentContext >& xContext,
uno::Reference< io::XInputStream > xInputStream,
uno::Reference< lang::XComponent > xModel,
SourceDocumentType eDocumentType) :
m_pImpl( new DomainMapper_Impl( *this, xContext, xModel, eDocumentType )),
mnBackgroundColor(0), mbIsHighlightSet(false)
{
// #i24363# tab stops relative to indent
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_TABS_RELATIVE_TO_INDENT ),
uno::makeAny( false ) );
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_PARA_TABLE_SPACING ),
uno::makeAny( false ) );
//import document properties
try
{
uno::Reference< lang::XMultiServiceFactory > xFactory(xContext->getServiceManager(), uno::UNO_QUERY_THROW);
uno::Reference< embed::XStorage > xDocumentStorage =
(comphelper::OStorageHelper::GetStorageOfFormatFromInputStream(OFOPXML_STORAGE_FORMAT_STRING, xInputStream));
uno::Reference< uno::XInterface > xTemp = xContext->getServiceManager()->createInstanceWithContext(
::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.OOXMLDocumentPropertiesImporter")),
xContext);
uno::Reference< document::XOOXMLDocumentPropertiesImporter > xImporter( xTemp, uno::UNO_QUERY_THROW );
uno::Reference< document::XDocumentPropertiesSupplier > xPropSupplier( xModel, uno::UNO_QUERY_THROW);
xImporter->importProperties( xDocumentStorage, xPropSupplier->getDocumentProperties() );
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
DomainMapper::~DomainMapper()
{
try
{
uno::Reference< text::XDocumentIndexesSupplier> xIndexesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
uno::Reference< container::XIndexAccess > xIndexes = xIndexesSupplier->getDocumentIndexes();
sal_Int32 nIndexes = xIndexes->getCount();
if( nIndexes )
{
//index update has to wait until first view is created
uno::Reference< document::XEventBroadcaster > xBroadcaster(xIndexesSupplier, uno::UNO_QUERY);
xBroadcaster->addEventListener(uno::Reference< document::XEventListener >(new ModelEventListener));
}
// Apply the document settings after everything else
m_pImpl->GetSettingsTable()->ApplyProperties( m_pImpl->GetTextDocument( ) );
}
catch( const uno::Exception& rEx )
{
(void)rEx;
}
delete m_pImpl;
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::attribute(Id nName, Value & val)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("attribute");
dmapper_logger->attribute("name", (*QNameToString::Instance())(nName));
dmapper_logger->attribute("value", val.toString());
dmapper_logger->endElement("attribute");
#endif
static ::rtl::OUString sLocalBookmarkName;
sal_Int32 nIntValue = val.getInt();
rtl::OUString sStringValue = val.getString();
SectionPropertyMap * pSectionContext = m_pImpl->GetSectionContext();
// printf ( "DomainMapper::attribute(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nName, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
if( nName >= NS_rtf::LN_WIDENT && nName <= NS_rtf::LN_LCBSTTBFUSSR )
m_pImpl->GetFIB().SetData( nName, nIntValue );
else //if( !m_pImpl->getTableManager().attribute( nName, val) )
{
/* WRITERFILTERSTATUS: table: attributedata */
switch( nName )
{
/* attributes to be ignored */
case NS_rtf::LN_UNUSED1_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED1_7:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_UNUSED8_3:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWRITERESERVATION:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FFAREAST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRYPTO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_NFIBBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LKEY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_ENVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FWORD97SAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNCHPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTECHP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNPAPFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTEPAP_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNLVCFIRST_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CPNBTELVC_W6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CBMAC:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LPRODUCTREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_CCPMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_PNFBPLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCISLANDLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTSHFORIG:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPAD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSEA:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBCMDS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFMCR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRDRVR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVPORT:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPRENVLAND:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBWSS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBAUTOSAVESOURCE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCDOAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFWKB:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFSPL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTWUSER:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFINTLFLD:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBROUTESLIP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBSAVEDBY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBSTTBFNM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBDOCUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBUSKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCRGBUSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCUPCUSP:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLGOSL:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCOCX:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWLOWDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_DWHIGHDATETIME:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCASUMY:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_LCBPLCFGRAM:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_rtf::LN_FCSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_rtf::LN_ISTD: //index of applied style
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//search for the style with the given id and apply it
//as CharStyleName or ParaStyleName
//if the style is a user defined style then it must have an ISTD - built-in styles might not have it
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
::rtl::OUString sValue = ::rtl::OUString::valueOf(nIntValue, 16);
const StyleSheetEntryPtr pEntry = pStyleSheets->FindStyleSheetByISTD(sValue);
if( pEntry.get( ) )
{
bool bParaStyle = (pEntry->nStyleTypeCode == STYLE_TYPE_PARA);
if(bParaStyle)
m_pImpl->SetCurrentParaStyleId(::rtl::OUString::valueOf(static_cast<sal_Int32>(nIntValue), 16));
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert(
bParaStyle ?
PROP_PARA_STYLE_NAME : PROP_CHAR_STYLE_NAME,
true,
uno::makeAny(
m_pImpl->GetStyleSheetTable()->ConvertStyleName( pEntry->sStyleName ) ) );
}
}
break;
case NS_rtf::LN_ISTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NFC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FLEGAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FNORESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FIDENTSAV:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FCONVERTED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FTENTATIVE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGBXCHNUMS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IXCHFOLLOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXASPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAINDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLCHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBGRPPRLPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LSID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_TPLC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGISTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSIMPLELIST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fAutoNum:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fHybrid:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ILVL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTARTAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFORMATTING:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNSIGNED4_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_clfolvl:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBFFNM1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PRQ:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FTRUETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WWEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CHS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetLNCHS( nIntValue );
}
break;
case NS_rtf::LN_IXCHSZALT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_PANOSE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STI:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSCRATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FINVALHEIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHASUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMASSCOPY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SGC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDBASE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CUPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BCHUPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FAUTOREDEF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FHIDDEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CSTD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBSTDBASEINFILE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSTDSTYLENAMESWRITTEN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED4_2:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STIMAXWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ISTDMAXFIXEDWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_NVERBUILTINNAMESWHENSAVED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_RGFTCSTANDARDCHPSTSH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_WIDENT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NFIB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_NPRODUCT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LID:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNNEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FDOT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FGLSY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCOMPLEX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FHASPIC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CQUICKSAVES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FENCRYPTED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FWHICHTBLSTM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FREADONLYRECOMMENDED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEXTCHAR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FEMPTYSPECIAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FLOADOVERRIDEPAGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FFUTURESAVEDUNDO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FSPARE0:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CHSTABLES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CSW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICCREATEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_WMAGICREVISEDPRIVATE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LIDFE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CLW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CCPHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNCHPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTECHP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNPAPFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTEPAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_PNLVCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CPNBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_CFCLCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTSHF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFNDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFANDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFPHE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTECHPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTEPAPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDATN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFASSOC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBCLX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBGRPXSTATNOWNERS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFATNBKMK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAMOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCSPAHDR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFATNBKL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBFORMFLDSTTBF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDREF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFENDTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBDGGINFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFRMARK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFAUTOCAPTION:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFHDRTXBXTXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFFLDHDRTXBX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBTTMBD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDMOTHER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDFTN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPGDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBBKDEDN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLFLFO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFTXBXHDRBKD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBGLSYSTYLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFBTELVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBPLCFLVC:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBLISTNAMES:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_LCBSTTBFUSSR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
m_pImpl->GetFIB().SetData( nName, nIntValue );
}
break;
case NS_rtf::LN_FN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCSEPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FNMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_FCMPR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//section descriptor, unused or internally used
break;
case NS_rtf::LN_ICOFORE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICOBACK:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_IPAT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDFORECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDBACKCOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_SHDPATTERN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTLINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ICO:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DPTSPACE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FSHADOW:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UNUSED2_15:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFIRSTMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FMERGED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBACKWARD:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FROTATEFONT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTMERGE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FVERTRESTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_VERTALIGN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FUNUSED:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_rtf::LN_BRCRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
(void)nLineDistance;
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nName )
{
case NS_rtf::LN_BRCTOP:
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCLEFT:
// eBorderId = PROP_LEFT_BORDER;
// eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_rtf::LN_BRCBOTTOM:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_rtf::LN_BRCRIGHT:
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
default:;
}
//todo: where to put the border properties
//rContext->Insert(eBorderId, uno::makeAny( aBorderLine ));
//rContext->Insert(eBorderDistId, uno::makeAny( nLineDistance ));
}
break;
case NS_rtf::LN_ITCFIRST:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FPUB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ITCLIM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FCOL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINECOLOR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEWIDTH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINETYPE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_YEXT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_HMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LCB:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CBHEADER:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MFP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BM_RCWINMF:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAGOAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_MY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXACROPRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYACROPBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BRCL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FFRAMEEMPTY:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FBITMAP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FDRAWHATCH:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FERROR:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BPP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DXAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_DYAORIGIN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_CPROPS:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSTOP:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSLEFT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSBOTTOM:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSRIGHT:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSHORIZONTAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LINEPROPSVERTICAL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_endnote:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_BOOKMARKNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// sStringValue contains the bookmark name
sLocalBookmarkName = sStringValue;
break;
case NS_rtf::LN_IBKL:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0.5 */
//contains the bookmark identifier - has to be added to the bookmark name imported before
//if it is already available then the bookmark should be inserted
m_pImpl->AddBookmark( sLocalBookmarkName, sStringValue );
sLocalBookmarkName = ::rtl::OUString();
break;
case NS_rtf::LN_LISTLEVEL:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFOData:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_F:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_ALTFONTNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSZFFN:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_XSTZNAME1:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPXSTART:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_UPX:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_sed:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//section properties
resolveAttributeProperties(val);
break;
case NS_rtf::LN_tbdAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
{
pProperties->resolve(*this);
//increment to the next tab stop
m_pImpl->NextTabStop();
}
}
break;
case NS_rtf::LN_dxaDel:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//deleted tab
case NS_rtf::LN_dxaAdd:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//set tab
case NS_rtf::LN_TLC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab leading characters - for decimal tabs
case NS_rtf::LN_JC:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//tab justification
m_pImpl->ModifyCurrentTabStop(nName, nIntValue);
break;
case NS_rtf::LN_UNUSED0_6:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// really unused
break;
case NS_rtf::LN_rgbrc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_shd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellShd:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_cellTopColor:
case NS_rtf::LN_cellLeftColor:
case NS_rtf::LN_cellBottomColor:
case NS_rtf::LN_cellRightColor:
OSL_ASSERT("handled by DomainMapperTableManager");
break;
case NS_rtf::LN_LISTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_rtf::LN_fcEastAsianLayout:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
/* it seems that the value is following:
???? XX YYYY ZZ
where
XX seems to be the run id
ZZ is the length of the function that is normally 6
Lower byte of YYYY determines whether it is
vertical text flow (0x01), or
two lines in one layout (0x02).
For 0x01, if the higher byte of YYYY is zero, the text is not scaled to fit the line height,
in oposite case, it is to be scaled.
For 0x02, the higher byte of YYYY is determinig the prefix and suffix of the run:
no brackets (0x00) ,
() round brackets (0x01),
[] square backets (0x02),
<> angle brackets (0x03) and
{} curly brackets (0x04).
???? is different and we do not know its signification
*/
if ((nIntValue & 0x000000FF) == 6)
{
switch ((nIntValue & 0x0000FF00) >> 8)
{
case 1: // vertical text
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( sal_Int16(900) ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny (((nIntValue & 0x00FF0000) >> 16) != 0));
}
break;
case 2: // two lines in one
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( true ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16)));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( getBracketStringFromEnum((nIntValue & 0x00FF0000) >> 16, false)));
}
break;
default:
break;
}
}
break;
case NS_rtf::LN_FRD :
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnote reference descriptor, if nIntValue > 0 then automatic, custom otherwise
//ignored
break;
case NS_rtf::LN_FONT: //font of footnote symbol
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteFontId( nIntValue );
break;
case NS_ooxml::LN_CT_Sym_char:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
m_pImpl->GetTopContext()->GetFootnote()->setLabel(::rtl::OUString( sal_Unicode(nIntValue)));
break;
}
else //it's a _real_ symbol
{
utext( reinterpret_cast < const sal_uInt8 * >( &nIntValue ), 1 );
}
break;
case NS_rtf::LN_CHAR: //footnote symbol character
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->SetFootnoteSymbol( sal_Unicode(nIntValue));
break;
case NS_ooxml::LN_CT_Sym_font:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//the footnote symbol and font are provided after the footnote is already inserted
if( m_pImpl->GetTopContext() && m_pImpl->GetTopContext()->GetFootnote().is())
{
uno::Reference< beans::XPropertySet > xAnchorProps( m_pImpl->GetTopContext()->GetFootnote()->getAnchor(), uno::UNO_QUERY );
xAnchorProps->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_CHAR_FONT_NAME),
uno::makeAny( sStringValue ));
}
else //a real symbol
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Underline_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
handleUnderlineType(nIntValue, m_pImpl->GetTopContext());
break;
case NS_ooxml::LN_CT_Color_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nIntValue ) );
break;
case NS_ooxml::LN_CT_Underline_color:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
m_pImpl->GetTopContext()->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nIntValue ) );
}
break;
case NS_ooxml::LN_CT_TabStop_val:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_ST_TabJc_clear)
m_pImpl->m_aCurrentTabStop.bDeleted = true;
else
{
m_pImpl->m_aCurrentTabStop.bDeleted = false;
m_pImpl->m_aCurrentTabStop.Alignment = getTabAlignFromValue(nIntValue);
}
break;
case NS_ooxml::LN_CT_TabStop_leader:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.FillChar = getFillCharFromValue(nIntValue);
break;
case NS_ooxml::LN_CT_TabStop_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->m_aCurrentTabStop.Position = ConversionHelper::convertTwipToMM100(nIntValue);
break;
case NS_ooxml::LN_CT_Fonts_ascii:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_asciiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Fonts_hAnsi:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;//unsupported
case NS_ooxml::LN_CT_Fonts_hAnsiTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break; //unsupported
case NS_ooxml::LN_CT_Fonts_eastAsia:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_ASIAN, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_eastAsiaTheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ) );
break;
case NS_ooxml::LN_CT_Fonts_cs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( sStringValue ));
break;
case NS_ooxml::LN_CT_Fonts_cstheme:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_FONT_NAME_COMPLEX, true, uno::makeAny( m_pImpl->GetThemeTable()->getFontNameForTheme(nIntValue) ));
break;
case NS_ooxml::LN_CT_Spacing_before:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_beforeLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_after:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case NS_ooxml::LN_CT_Spacing_afterLines:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_Spacing_line: //91434
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Spacing_lineRule: //91435
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
#define SINGLE_LINE_SPACING 240
style::LineSpacing aSpacing;
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
PropertyMap::iterator aLineSpacingIter = pTopContext->find(PropertyDefinition( PROP_PARA_LINE_SPACING, true ) );
if( aLineSpacingIter != pTopContext->end())
{
aLineSpacingIter->second >>= aSpacing;
}
else
{
//default to single line spacing
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
if( nName == NS_ooxml::LN_CT_Spacing_line )
{
//now set the value depending on the Mode
if( aSpacing.Mode == style::LineSpacingMode::PROP )
aSpacing.Height = sal_Int16(sal_Int32(nIntValue) * 100 / SINGLE_LINE_SPACING );
else
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100( nIntValue ));
}
else //NS_ooxml::LN_CT_Spacing_lineRule:
{
// exactly, atLeast, auto
if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_auto)
{
aSpacing.Mode = style::LineSpacingMode::PROP;
//reinterpret the already set value
aSpacing.Height = sal_Int16( aSpacing.Height * 100 / ConversionHelper::convertTwipToMM100( SINGLE_LINE_SPACING ));
}
else if( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_atLeast)
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
else // NS_ooxml::LN_Value_wordprocessingml_ST_LineSpacingRule_exact
aSpacing.Mode = style::LineSpacingMode::FIX;
}
pTopContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case NS_ooxml::LN_CT_Ind_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_LEFT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_RIGHT_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_hanging:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( - ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_Ind_firstLine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(
PROP_PARA_FIRST_LINE_INDENT, true, uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_CT_EastAsianLayout_combine:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_IS_ON, true, uno::makeAny ( nIntValue ? true : false ));
break;
case NS_ooxml::LN_CT_EastAsianLayout_combineBrackets:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
rtl::OUString sCombinePrefix = getBracketStringFromEnum(nIntValue);
rtl::OUString sCombineSuffix = getBracketStringFromEnum(nIntValue, false);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_PREFIX, true, uno::makeAny ( sCombinePrefix ));
m_pImpl->GetTopContext()->Insert(PROP_CHAR_COMBINE_SUFFIX, true, uno::makeAny ( sCombineSuffix ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vert:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
{
sal_Int16 nRotationAngle = (nIntValue ? 900 : 0);
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION, true, uno::makeAny ( nRotationAngle ));
}
break;
case NS_ooxml::LN_CT_EastAsianLayout_vertCompress:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(PROP_CHAR_ROTATION_IS_FIT_TO_LINE, true, uno::makeAny ( nIntValue ? true : false));
break;
case NS_ooxml::LN_CT_PageSz_code:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = nIntValue;
break;
case NS_ooxml::LN_CT_PageSz_h:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.h = PaperInfo::sloppyFitPageDimension(nHeight);
}
break;
case NS_ooxml::LN_CT_PageSz_orient:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.orient = (nIntValue != 0);
break;
case NS_ooxml::LN_CT_PageSz_w:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100(nIntValue);
CT_PageSz.w = PaperInfo::sloppyFitPageDimension(nWidth);
}
break;
case NS_ooxml::LN_CT_PageMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_TOP, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_RIGHT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_BOTTOM, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_LEFT, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_header:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_HEADER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_footer:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_FOOTER, nIntValue );
break;
case NS_ooxml::LN_CT_PageMar_gutter:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetPageMarginTwip( PAGE_MAR_GUTTER, nIntValue );
break;
case NS_ooxml::LN_CT_Language_val: //90314
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_eastAsia: //90315
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Language_bidi: //90316
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
LanguageType eLang = MsLangId::convertIsoStringToLanguage( sStringValue );
lang::Locale aLocale = MsLangId::convertLanguageToLocale( eLang );
if (m_pImpl->GetTopContext())
m_pImpl->GetTopContext()->Insert(NS_ooxml::LN_CT_Language_val== nName ? PROP_CHAR_LOCALE :
NS_ooxml::LN_CT_Language_eastAsia == nName ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
#define AUTO_PARA_SPACING sal_Int32(49)
case NS_ooxml::LN_CT_Spacing_beforeAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
//and should be set to 0 on start of page
m_pImpl->GetTopContext()->Insert( PROP_PARA_TOP_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_Spacing_afterAutospacing:
/* WRITERFILTERSTATUS: done: 80, planned: 0.5, spent: 0.2 */
//TODO: autospacing depends on some document property (called fDontUseHTMLAutoSpacing in old ww8 filter) 100 or 280 twip
m_pImpl->GetTopContext()->Insert( PROP_PARA_BOTTOM_MARGIN, false, uno::makeAny( AUTO_PARA_SPACING ) );
break;
case NS_ooxml::LN_CT_SmartTagRun_uri:
case NS_ooxml::LN_CT_SmartTagRun_element:
/* WRITERFILTERSTATUS: done: 0, planned: 1, spent: 0 */
//TODO: add handling of SmartTags
break;
case NS_ooxml::LN_CT_Br_type :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//TODO: attributes for break (0x12) are not supported
break;
case NS_ooxml::LN_CT_Fonts_hint :
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
/* assigns script type to ambigous characters, values can be:
NS_ooxml::LN_Value_ST_Hint_default
NS_ooxml::LN_Value_ST_Hint_eastAsia
NS_ooxml::LN_Value_ST_Hint_cs
*/
//TODO: unsupported?
break;
case NS_ooxml::LN_CT_TblCellMar_right: // 92375;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_top: // 92377;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_left: // 92378;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TblBorders_bottom: // 92379;
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//todo: handle cell mar
break;
case NS_rtf::LN_blip: // contains the binary graphic
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_shape:
/* WRITERFILTERSTATUS: done: 50, planned: 0.5, spent: 0 */
{
//looks a bit like a hack - and it is. The graphic import is split into the inline_inline part and
//afterwards the adding of the binary data.
m_pImpl->GetGraphicImport( IMPORT_AS_DETECTED_INLINE )->attribute(nName, val);
m_pImpl->ImportGraphic( val.getProperties(), IMPORT_AS_DETECTED_INLINE );
}
break;
case NS_ooxml::LN_CT_FramePr_dropCap:
case NS_ooxml::LN_CT_FramePr_lines:
case NS_ooxml::LN_CT_FramePr_hAnchor:
case NS_ooxml::LN_CT_FramePr_vAnchor:
case NS_ooxml::LN_CT_FramePr_x:
case NS_ooxml::LN_CT_FramePr_xAlign:
case NS_ooxml::LN_CT_FramePr_y:
case NS_ooxml::LN_CT_FramePr_yAlign:
case NS_ooxml::LN_CT_FramePr_hRule:
case NS_sprm::LN_PWr:
case NS_sprm::LN_PDxaWidth:
case NS_sprm::LN_PWHeightAbs:
case NS_sprm::LN_PDxaFromText:
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
ParagraphProperties* pParaProperties = dynamic_cast< ParagraphProperties*>(m_pImpl->GetTopContext().get());
if( pParaProperties )
{
switch( nName )
{
case NS_ooxml::LN_CT_FramePr_dropCap:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetDropCap( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_lines:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetLines( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_text: //relative to column
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_margin: nIntValue = text::RelOrientation::PAGE_PRINT_AREA; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SethAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_vAnchor:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch(nIntValue)
{
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_text: //relative to paragraph
nIntValue = text::RelOrientation::FRAME; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_margin:nIntValue = text::RelOrientation::PAGE_PRINT_AREA ; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_VAnchor_page: nIntValue = text::RelOrientation::PAGE_FRAME; break;
default:;
}
pParaProperties->SetvAnchor( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_x:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setx( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_xAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_center : nIntValue = text::HoriOrientation::CENTER; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_right : nIntValue = text::HoriOrientation::RIGHT; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_inside : nIntValue = text::HoriOrientation::INSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_outside : nIntValue = text::HoriOrientation::OUTSIDE; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_XAlign_left : nIntValue = text::HoriOrientation::LEFT; break;
default: nIntValue = text::HoriOrientation::NONE;
}
pParaProperties->SetxAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_y:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Sety( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_ooxml::LN_CT_FramePr_yAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_top :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inside :nIntValue = text::VertOrientation::TOP; break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_center :nIntValue = text::VertOrientation::CENTER;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_bottom :
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_outside :nIntValue = text::VertOrientation::BOTTOM;break;
case NS_ooxml::LN_Value_wordprocessingml_ST_YAlign_inline ://todo: what to do with inline - no avail. in WW97 and WW2007
//no break;
default:nIntValue = text::VertOrientation::NONE;
}
pParaProperties->SetyAlign( nIntValue );
break;
case NS_ooxml::LN_CT_FramePr_hRule:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
switch( nIntValue )
{
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_exact:
nIntValue = text::SizeType::FIX;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_atLeast:
nIntValue = text::SizeType::MIN;
break;
case NS_ooxml::LN_Value_wordprocessingml_ST_HeightRule_auto:
//no break;
default:;
nIntValue = text::SizeType::VARIABLE;
}
pParaProperties->SethRule( nIntValue );
break;
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//should be either LN_Value_wordprocessingml_ST_Wrap_notBeside or LN_Value_wordprocessingml_ST_Wrap_around
OSL_ENSURE( sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ||
sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_notBeside,
"wrap not around or not_Beside?");
pParaProperties->SetWrap(sal::static_int_cast<Id>(nIntValue) == NS_ooxml::LN_Value_wordprocessingml_ST_Wrap_around ?
text::WrapTextMode_DYNAMIC : text::WrapTextMode_NONE );
}
break;
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Setw(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->Seth(ConversionHelper::convertTwipToMM100(nIntValue));
break;
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SethSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
pParaProperties->SetvSpace( ConversionHelper::convertTwipToMM100(nIntValue ));
break;
default:;
}
}
else
{
//TODO: how to handle frame properties at styles
}
}
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_TrackChange_author:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineAuthor( sStringValue );
break;
case NS_ooxml::LN_CT_TrackChange_date:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineDate( sStringValue );
break;
case NS_ooxml::LN_CT_Markup_id:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineId( nIntValue );
break;
case NS_ooxml::LN_token:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCurrentRedlineToken( nIntValue );
break;
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
//line numbering in Writer is a global document setting
//in Word is a section setting
//if line numbering is switched on anywhere in the document it's set at the global settings
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
switch( nName )
{
case NS_ooxml::LN_CT_LineNumber_countBy:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nInterval = nIntValue;
break;
case NS_ooxml::LN_CT_LineNumber_start:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nStartValue = nIntValue; // todo: has to be set at (each) first paragraph
break;
case NS_ooxml::LN_CT_LineNumber_distance:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
aSettings.nDistance = ConversionHelper::convertTwipToMM100( nIntValue );
break;
case NS_ooxml::LN_CT_LineNumber_restart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page:empty, probably 0,section:1,continuous:2;
aSettings.bRestartAtEachPage = nIntValue < 1;
break;
default:;
}
m_pImpl->SetLineNumberSettings( aSettings );
}
break;
case NS_ooxml::LN_CT_FtnEdnRef_customMarkFollows:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetCustomFtnMark( true );
break;
case NS_ooxml::LN_CT_FtnEdnRef_id:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
// footnote or endnote reference id - not needed
case NS_ooxml::LN_CT_Color_themeColor:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeTint:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_Color_themeShade:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
//unsupported
break;
case NS_ooxml::LN_endtrackchange:
m_pImpl->RemoveCurrentRedline( );
break;
case NS_ooxml::LN_CT_DocGrid_linePitch:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//see SwWW8ImplReader::SetDocumentGrid
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetGridLinePitch( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case NS_ooxml::LN_CT_DocGrid_charSpace:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDxtCharSpace( nIntValue );
}
}
break;
case NS_ooxml::LN_CT_DocGrid_type:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
if (pSectionContext != NULL)
{
pSectionContext->SetGridType(nIntValue);
}
}
break;
default:
{
#if OSL_DEBUG_LEVEL > 0
::rtl::OString sMessage( "DomainMapper::attribute() - Id: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nName ), 16 );
// sMessage += ::rtl::OString(" / ");
// sMessage += ::rtl::OString
// ((*QNameToString::Instance())(nName).c_str());
sMessage += ::rtl::OString(" value: ");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 10 );
sMessage += ::rtl::OString(" / 0x");
sMessage += ::rtl::OString::valueOf( sal_Int32( nIntValue ), 16 );
OSL_ENSURE( false, sMessage.getStr()); //
#endif
}
}
}
}
/*-- 09.06.2006 09:52:12---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm(Sprm & rSprm)
{
if( !m_pImpl->getTableManager().sprm(rSprm))
DomainMapper::sprm( rSprm, m_pImpl->GetTopContext() );
}
/*-- 20.06.2006 09:58:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::sprm( Sprm& rSprm, PropertyMapPtr rContext, SprmType eSprmType )
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("sprm");
dmapper_logger->chars(rSprm.toString());
#endif
OSL_ENSURE(rContext.get(), "PropertyMap has to be valid!");
if(!rContext.get())
return ;
sal_uInt32 nSprmId = rSprm.getId();
//needed for page properties
SectionPropertyMap * pSectionContext = m_pImpl->GetSectionContext();
//TODO: In rtl-paragraphs the meaning of left/right are to be exchanged
bool bExchangeLeftRight = false;
// if( nSprmId == NS_sprm::LN_PJcExtra && AlreadyInRTLPara() )
// bExchangeLeftRight = true;
Value::Pointer_t pValue = rSprm.getValue();
sal_Int32 nIntValue = pValue->getInt();
rtl::OUString sStringValue = pValue->getString();
// printf ( "DomainMapper::sprm(0x%.4x, 0x%.4x) [%s]\n", (unsigned int)nSprmId, (unsigned int)nIntValue, ::rtl::OUStringToOString(sStringValue, RTL_TEXTENCODING_DONTKNOW).getStr());
/* WRITERFILTERSTATUS: table: sprmdata */
switch(nSprmId)
{
case 2: // sprmPIstd
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
case 0x4600:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstd - style code
case 3: // "sprmPIstdPermute
case NS_sprm::LN_PIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIstdPermute
case NS_sprm::LN_PIncLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPIncLvl
case NS_sprm::LN_PJcExtra: // sprmPJc Asian (undocumented)
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PJc: // sprmPJc
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
handleParaJustification(nIntValue, rContext, bExchangeLeftRight);
break;
case NS_sprm::LN_PFSideBySide:
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
break; // sprmPFSideBySide
case NS_sprm::LN_PFKeep: // sprmPFKeep
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_SPLIT, true, uno::makeAny(nIntValue ? false : true));
break;
case NS_sprm::LN_PFKeepFollow: // sprmPFKeepFollow
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_KEEP_TOGETHER, true, uno::makeAny( nIntValue ? true : false) );
break;
case NS_sprm::LN_PFPageBreakBefore:
/* WRITERFILTERSTATUS: done: 100, planned: 3, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE ) );
break; // sprmPFPageBreakBefore
case NS_sprm::LN_PBrcl:
break; // sprmPBrcl
case NS_sprm::LN_PBrcp:
break; // sprmPBrcp
case NS_sprm::LN_PIlvl: // sprmPIlvl
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
//todo: Numbering level will be implemented in the near future (OOo 3.0?)
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListLevel( (sal_Int16)nIntValue );
}
else
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny( (sal_Int16)nIntValue ));
break;
case NS_sprm::LN_PIlfo: // sprmPIlfo
/* WRITERFILTERSTATUS: done: 50, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
{
//convert the ListTable entry to a NumberingRules propery and apply it
sal_Int32 nListId = m_pImpl->GetLFOTable()->GetListID( nIntValue );
if(nListId >= 0)
{
ListTablePtr pListTable = m_pImpl->GetListTable();
if( m_pImpl->IsStyleSheetImport() )
{
//style sheets cannot have a numbering rule attached
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetListId( nListId );
}
else
rContext->Insert( PROP_NUMBERING_RULES, true,
uno::makeAny(pListTable->GetNumberingRules(nListId)));
//TODO: Merge overwrittern numbering levels from LFO table
}
}
break;
case NS_sprm::LN_PFNoLineNumb: // sprmPFNoLineNumb
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
/* WRITERFILTERSTATUS: comment: */
rContext->Insert(PROP_PARA_LINE_NUMBER_COUNT, true, uno::makeAny( nIntValue ? false : true) );
break;
case NS_sprm::LN_PChgTabsPapx: // sprmPChgTabsPapx
/* WRITERFILTERSTATUS: done: 90, planned: 8, spent: 8 */
/* WRITERFILTERSTATUS: comment: bar tab stops a unavailable */
{
// Initialize tab stop vector from style sheet
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
//create a new tab stop property - this is done with the contained properties
resolveSprmProps(rSprm);
//add this property
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case 0x845d: //right margin Asian - undocumented
case 0x845e: //left margin Asian - undocumented
case 16: // sprmPDxaRight - right margin
case NS_sprm::LN_PDxaRight: // sprmPDxaRight - right margin
case 17:
case NS_sprm::LN_PDxaLeft: // sprmPDxaLeft
/* WRITERFILTERSTATUS: done: 50, planned: 5, spent: 1 */
if( NS_sprm::LN_PDxaLeft == nSprmId || 0x17 == nSprmId|| (bExchangeLeftRight && nSprmId == 0x845d) || ( !bExchangeLeftRight && nSprmId == 0x845e))
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_LEFT_MARGIN : PROP_LEFT_MARGIN,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
else if(eSprmType == SPRM_DEFAULT)
rContext->Insert(
PROP_PARA_RIGHT_MARGIN, true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
//TODO: what happens to the right margins in numberings?
break;
case 18: // sprmPNest
case NS_sprm::LN_PNest: // sprmPNest
//not handled in the old WW8 filter
break;
case NS_sprm::LN_PDxaLeft1: // sprmPDxaLeft1
case 19:
case NS_sprm::LN_PDxaLeft180: // sprmPDxaLeft180
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(
eSprmType == SPRM_DEFAULT ? PROP_PARA_FIRST_LINE_INDENT : PROP_FIRST_LINE_OFFSET,
true,
uno::makeAny( ConversionHelper::convertTwipToMM100(nIntValue ) ));
break;
case 20 : // sprmPDyaLine
case NS_sprm::LN_PDyaLine: // sprmPDyaLine
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
{
style::LineSpacing aSpacing;
sal_Int16 nDistance = sal_Int16(nIntValue & 0xffff);
if(nIntValue & 0xffff0000)
{
// single line in Writer is 100, in Word it is 240
aSpacing.Mode = style::LineSpacingMode::PROP;
aSpacing.Height = sal_Int16(sal_Int32(nDistance) * 100 /240);
}
else
{
if(nDistance < 0)
{
aSpacing.Mode = style::LineSpacingMode::FIX;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(-nDistance));
}
else if(nDistance >0)
{
aSpacing.Mode = style::LineSpacingMode::MINIMUM;
aSpacing.Height = sal_Int16(ConversionHelper::convertTwipToMM100(nDistance));
}
}
rContext->Insert(PROP_PARA_LINE_SPACING, true, uno::makeAny( aSpacing ));
}
break;
case 21 : // legacy version
case NS_sprm::LN_PDyaBefore: // sprmPDyaBefore
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_TOP_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 22 :
case NS_sprm::LN_PDyaAfter: // sprmPDyaAfter
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 1 */
rContext->Insert(PROP_PARA_BOTTOM_MARGIN, true, uno::makeAny( ConversionHelper::convertTwipToMM100( nIntValue ) ));
break;
case 23: //sprmPChgTabs
case NS_sprm::LN_PChgTabs: // sprmPChgTabs
/* WRITERFILTERSTATUS: done: 0, planned: 3, spent: 0 */
OSL_ENSURE( false, "unhandled");
//tabs of list level?
break;
case 24: // "sprmPFInTable"
case NS_sprm::LN_PFInTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFInTable
case NS_sprm::LN_PTableDepth: //sprmPTableDepth
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//not handled via sprm but via text( 0x07 )
break;
case 25: // "sprmPTtp" pap.fTtp
case NS_sprm::LN_PFTtp: // sprmPFTtp was: Read_TabRowEnd
break;
case 26: // "sprmPDxaAbs
case NS_sprm::LN_PDxaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaAbs
case 27: //sprmPDyaAbs
case NS_sprm::LN_PDyaAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaAbs
case NS_sprm::LN_PDxaWidth:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaWidth
case NS_sprm::LN_PPc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPc
case NS_sprm::LN_PBrcTop10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcTop10
case NS_sprm::LN_PBrcLeft10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcLeft10
case NS_sprm::LN_PBrcBottom10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBottom10
case NS_sprm::LN_PBrcRight10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcRight10
case NS_sprm::LN_PBrcBetween10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBetween10
case NS_sprm::LN_PBrcBar10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar10
case NS_sprm::LN_PDxaFromText10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText10
case NS_sprm::LN_PWr:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWr
case NS_ooxml::LN_CT_PrBase_pBdr: //paragraph border
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
resolveSprmProps(rSprm);
break;
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: page borders are no handled yet, conversion incomplete */
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: done: 0, planned: 8, spent: 0 */
/* WRITERFILTERSTATUS: comment: */
{
//in binary format the borders are directly provided in OOXML they are inside of properties
if( IsOOXMLImport() )
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
BorderHandlerPtr pBorderHandler( new BorderHandler( true ) );
pProperties->resolve(*pBorderHandler);
PropertyIds eBorderId = PropertyIds( 0 );
PropertyIds eBorderDistId = PropertyIds( 0 );
switch( nSprmId )
{
case NS_sprm::LN_PBrcTop:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcLeft:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcRight:
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcBetween:
/* WRITERFILTERSTATUS: */
//not supported
break;
default:;
}
if( eBorderId )
rContext->Insert( eBorderId, true, uno::makeAny( pBorderHandler->getBorderLine()) , true);
if(eBorderDistId)
rContext->Insert(eBorderDistId, true, uno::makeAny( pBorderHandler->getLineDistance()), true);
}
}
else
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
PropertyIds eBorderId = PROP_LEFT_BORDER;
PropertyIds eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
switch( nSprmId )
{
case NS_sprm::LN_PBrcBetween: // sprmPBrcBetween
/* WRITERFILTERSTATUS: */
OSL_ENSURE( false, "TODO: inner border is not handled");
break;
case NS_sprm::LN_PBrcLeft: // sprmPBrcLeft
/* WRITERFILTERSTATUS: */
eBorderId = PROP_LEFT_BORDER;
eBorderDistId = PROP_LEFT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcRight: // sprmPBrcRight
/* WRITERFILTERSTATUS: */
eBorderId = PROP_RIGHT_BORDER ;
eBorderDistId = PROP_RIGHT_BORDER_DISTANCE ;
break;
case NS_sprm::LN_PBrcTop: // sprmPBrcTop
/* WRITERFILTERSTATUS: */
eBorderId = PROP_TOP_BORDER ;
eBorderDistId = PROP_TOP_BORDER_DISTANCE;
break;
case NS_sprm::LN_PBrcBottom: // sprmPBrcBottom
/* WRITERFILTERSTATUS: */
default:
eBorderId = PROP_BOTTOM_BORDER ;
eBorderDistId = PROP_BOTTOM_BORDER_DISTANCE;
}
rContext->Insert(eBorderId, true, uno::makeAny( aBorderLine ));
rContext->Insert(eBorderDistId, true, uno::makeAny( nLineDistance ));
}
}
break;
case NS_sprm::LN_PBorderTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
case NS_sprm::LN_PBorderRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
/* WRITERFILTERSTATUS: comment: probably _real_ border colors, unhandled */
OSL_ENSURE( false, "TODO: border color definition");
break;
case NS_sprm::LN_PBrcBar:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPBrcBar
case NS_sprm::LN_PFNoAutoHyph: // sprmPFNoAutoHyph
/* WRITERFILTERSTATUS: done: 100, planned: 1, spent: 0 */
rContext->Insert(PROP_PARA_IS_HYPHENATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PWHeightAbs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWHeightAbs
case NS_sprm::LN_PDcs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDcs
case NS_sprm::LN_PShd: // sprmPShd
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 2 */
{
//contains fore color, back color and shadow percentage, results in a brush
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
CellColorHandlerPtr pCellColorHandler( new CellColorHandler );
pCellColorHandler->setParagraph();
pProperties->resolve(*pCellColorHandler);
rContext->insert( pCellColorHandler->getProperties(), true );
}
}
break;
case NS_sprm::LN_PDyaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDyaFromText
case NS_sprm::LN_PDxaFromText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPDxaFromText
case NS_sprm::LN_PFLocked:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFLocked
case NS_sprm::LN_PFWidowControl:
case NS_ooxml::LN_CT_PPrBase_widowControl:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
uno::Any aVal( uno::makeAny( sal_Int8(nIntValue ? 2 : 0 )));
rContext->Insert( PROP_PARA_WIDOWS, true, aVal );
rContext->Insert( PROP_PARA_ORPHANS, true, aVal );
}
break; // sprmPFWidowControl
case NS_sprm::LN_PRuler:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPRuler
case NS_sprm::LN_PFKinsoku:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFKinsoku
case NS_sprm::LN_PFWordWrap:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFWordWrap
case NS_sprm::LN_PFOverflowPunct: ; // sprmPFOverflowPunct - hanging punctuation
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_PARA_IS_HANGING_PUNCTUATION, true, uno::makeAny( nIntValue ? false : true ));
break;
case NS_sprm::LN_PFTopLinePunct:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFTopLinePunct
case NS_sprm::LN_PFAutoSpaceDE:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDE
case NS_sprm::LN_PFAutoSpaceDN:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAutoSpaceDN
case NS_sprm::LN_PWAlignFont:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPWAlignFont
case NS_sprm::LN_PFrameTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFrameTextFlow
case NS_sprm::LN_PISnapBaseLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPISnapBaseLine
case NS_sprm::LN_PAnld:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPAnld
case NS_sprm::LN_PPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPPropRMark
case NS_sprm::LN_POutLvl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
if( m_pImpl->IsStyleSheetImport() )
{
sal_Int16 nLvl = static_cast< sal_Int16 >( nIntValue );
StyleSheetPropertyMap* pStyleSheetPropertyMap = dynamic_cast< StyleSheetPropertyMap* >( rContext.get() );
pStyleSheetPropertyMap->SetOutlineLevel( nLvl );
}
}
break; // sprmPOutLvl
case NS_sprm::LN_PFBiDi:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_WRITING_MODE, false, uno::makeAny( text::WritingMode2::RL_TB ));
rContext->Insert(PROP_PARA_ADJUST, false, uno::makeAny( style::ParagraphAdjust_RIGHT ));
break; // sprmPFBiDi
case NS_ooxml::LN_EG_SectPrContents_bidi:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
if (pSectionContext != NULL)
pSectionContext->Insert(PROP_WRITING_MODE,false, uno::makeAny( text::WritingMode2::RL_TB));
break;
case NS_sprm::LN_PFNumRMIns:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFNumRMIns
case NS_sprm::LN_PCrLf:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPCrLf
case NS_sprm::LN_PNumRM:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPNumRM
case NS_sprm::LN_PHugePapx:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPHugePapx
case NS_sprm::LN_PFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFUsePgsuSettings
case NS_sprm::LN_PFAdjustRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPFAdjustRight
case NS_sprm::LN_CFRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMarkDel
case NS_sprm::LN_CFRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFRMark
case NS_sprm::LN_CFFldVanish:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFldVanish
case NS_sprm::LN_CFSpec: // sprmCFSpec
break;
case NS_sprm::LN_CPicLocation: // sprmCPicLocation
//is being resolved on the tokenizer side
break;
case NS_sprm::LN_CIbstRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMark
case NS_sprm::LN_CDttmRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMark
case NS_sprm::LN_CFData:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFData
case NS_sprm::LN_CIdslRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMark
case NS_sprm::LN_CChs:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCChs
case NS_sprm::LN_CSymbol: // sprmCSymbol
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
resolveSprmProps(rSprm); //resolves LN_FONT and LN_CHAR
break;
case NS_sprm::LN_CFOle2:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFOle2
case NS_sprm::LN_CIdCharType:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdCharType
case NS_sprm::LN_CHighlight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if(true ==( mbIsHighlightSet = getColorFromIndex(nIntValue, nColor)))
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( nColor ));
else if (mnBackgroundColor)
rContext->Insert(PROP_CHAR_BACK_COLOR, true, uno::makeAny( mnBackgroundColor ));
}
break; // sprmCHighlight
case NS_sprm::LN_CObjLocation:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCObjLocation
case NS_sprm::LN_CFFtcAsciSymb:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFFtcAsciSymb
case NS_sprm::LN_CIstd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstd
case NS_sprm::LN_CIstdPermute:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIstdPermute
case NS_sprm::LN_CDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDefault
case NS_sprm::LN_CPlain:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPlain
case NS_sprm::LN_CKcd:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_EMPHASIS, true, uno::makeAny ( getEmphasisValue (nIntValue)));
break; // sprmCKcd
case NS_sprm::LN_CFEmboss:// sprmCFEmboss
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi:// sprmCFBoldBi (offset 0x27 to normal bold)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalicBi:// sprmCFItalicBi (offset 0x27 to normal italic)
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFBold: //sprmCFBold
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case 61: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFItalic: //sprmCFItalic
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFStrike: //sprmCFStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5*/
case NS_sprm::LN_CFOutline: //sprmCFOutline
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFShadow: //sprmCFShadow
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFSmallCaps: //sprmCFSmallCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFCaps: //sprmCFCaps
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFVanish: //sprmCFVanish
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
case NS_sprm::LN_CFDStrike: // sprmCFDStrike
/* WRITERFILTERSTATUS: done: 100, planned: , spent: 0.5 */
{
PropertyIds ePropertyId = PROP_CHAR_WEIGHT; //initialized to prevent warning!
switch( nSprmId )
{
case 60:// sprmCFBold
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
case NS_sprm::LN_CFBold: /*sprmCFBold*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId != NS_sprm::LN_CFBoldBi ? PROP_CHAR_WEIGHT : PROP_CHAR_WEIGHT_COMPLEX;
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
/* WRITERFILTERSTATUS: */
ePropertyId = nSprmId == 0x836 ? PROP_CHAR_POSTURE : PROP_CHAR_POSTURE_COMPLEX;
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_STRIKEOUT;
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CONTOURED;
break;
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_SHADOWED;
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_CASE_MAP;
break;
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_HIDDEN;
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
ePropertyId = PROP_CHAR_RELIEF;
break;
}
//expected: 0,1,128,129
if(nIntValue != 128) //inherited from paragraph - ignore
{
if( nIntValue == 129) //inverted style sheet value
{
//get value from style sheet and invert it
sal_Int16 nStyleValue = 0;
double fDoubleValue;
uno::Any aStyleVal = m_pImpl->GetPropertyFromStyleSheet(ePropertyId);
if( !aStyleVal.hasValue() )
{
nIntValue = 0x83a == nSprmId ?
4 : 1;
}
else if(aStyleVal.getValueTypeClass() == uno::TypeClass_FLOAT )
{
//only in case of awt::FontWeight
aStyleVal >>= fDoubleValue;
nIntValue = fDoubleValue > 100. ? 0 : 1;
}
else if((aStyleVal >>= nStyleValue) ||
(nStyleValue = (sal_Int16)comphelper::getEnumAsINT32(aStyleVal)) >= 0 )
{
nIntValue = 0x83a == nSprmId ?
nStyleValue ? 0 : 4 :
nStyleValue ? 0 : 1;
}
else
{
OSL_ENSURE( false, "what type was it");
}
}
switch( nSprmId )
{
case 60:/*sprmCFBold*/
case NS_sprm::LN_CFBold: /*sprmCFBold*/
case NS_sprm::LN_CFBoldBi: // sprmCFBoldBi
/* WRITERFILTERSTATUS: */
{
uno::Any aBold( uno::makeAny( nIntValue ? awt::FontWeight::BOLD : awt::FontWeight::NORMAL ) );
rContext->Insert(ePropertyId, true, aBold );
if( nSprmId != NS_sprm::LN_CFBoldBi ) // sprmCFBoldBi
rContext->Insert(PROP_CHAR_WEIGHT_ASIAN, true, aBold );
}
break;
case 61: /*sprmCFItalic*/
case NS_sprm::LN_CFItalic: /*sprmCFItalic*/
case NS_sprm::LN_CFItalicBi: // sprmCFItalicBi
/* WRITERFILTERSTATUS: */
{
uno::Any aPosture( uno::makeAny( nIntValue ? awt::FontSlant_ITALIC : awt::FontSlant_NONE ) );
rContext->Insert( ePropertyId, true, aPosture );
if( nSprmId != NS_sprm::LN_CFItalicBi ) // sprmCFItalicBi
rContext->Insert(PROP_CHAR_POSTURE_ASIAN, true, aPosture );
}
break;
case NS_sprm::LN_CFStrike: /*sprmCFStrike*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontStrikeout::SINGLE : awt::FontStrikeout::NONE ) );
break;
case NS_sprm::LN_CFDStrike : /*sprmCFDStrike double strike through*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( awt::FontStrikeout::DOUBLE ) );
break;
case NS_sprm::LN_CFOutline: /*sprmCFOutline*/
case NS_sprm::LN_CFShadow: /*sprmCFShadow*/
case NS_sprm::LN_CFVanish: /*sprmCFVanish*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true, uno::makeAny( nIntValue ? true : false ));
break;
case NS_sprm::LN_CFSmallCaps: /*sprmCFSmallCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::SMALLCAPS : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFCaps: /*sprmCFCaps*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? style::CaseMap::UPPERCASE : style::CaseMap::NONE));
break;
case NS_sprm::LN_CFEmboss: /*sprmCFEmboss*/
/* WRITERFILTERSTATUS: */
rContext->Insert(ePropertyId, true,
uno::makeAny( nIntValue ? awt::FontRelief::EMBOSSED : awt::FontRelief::NONE ));
break;
}
}
}
break;
case NS_sprm::LN_CFtcDefault:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFtcDefault
case NS_sprm::LN_CKul: // sprmCKul
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
// Parameter: 0 = none, 1 = single, 2 = by Word,
// 3 = double, 4 = dotted, 5 = hidden
// 6 = thick, 7 = dash, 8 = dot(not used)
// 9 = dotdash 10 = dotdotdash 11 = wave
handleUnderlineType(nIntValue, rContext);
}
break;
case NS_sprm::LN_CSizePos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCSizePos
case NS_sprm::LN_CLid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCLid
case NS_sprm::LN_CIco:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
sal_Int32 nColor = 0;
if (getColorFromIndex(nIntValue, nColor))
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break; // sprmCIco
case NS_sprm::LN_CHpsBi: // sprmCHpsBi
case NS_sprm::LN_CHps: // sprmCHps
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//multiples of half points (12pt == 24)
double fVal = double(nIntValue) / 2.;
uno::Any aVal = uno::makeAny( fVal );
if( NS_sprm::LN_CHpsBi == nSprmId )
rContext->Insert( PROP_CHAR_HEIGHT_COMPLEX, true, aVal );
else
{
//Asian get the same value as Western
rContext->Insert( PROP_CHAR_HEIGHT, true, aVal );
rContext->Insert( PROP_CHAR_HEIGHT_ASIAN, true, aVal );
}
}
break;
case NS_sprm::LN_CHpsInc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc
case NS_sprm::LN_CHpsPos:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
{
// FIXME: ww8 filter in ww8par6.cxx has a Read_SubSuperProp function
// that counts the escapement from this value and font size. So it will be
// on our TODO list
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 100;
if (nIntValue < 0)
nEscapement = -58;
else if (nIntValue > 0)
nEscapement = 58;
else /* (nIntValue == 0) */
nProp = 0;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break; // sprmCHpsPos
case NS_sprm::LN_CHpsPosAdj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsPosAdj
case NS_sprm::LN_CMajority:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority
case NS_sprm::LN_CIss: // sprmCIss
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
//sub/super script 1: super, 2: sub, 0: normal
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
switch(nIntValue)
{
case 1: //super
nEscapement = 101;
break;
case 2: //sub
nEscapement = -101;
break;
case 0: nProp = 0;break; //none
}
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
case NS_sprm::LN_CHpsNew50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsNew50
case NS_sprm::LN_CHpsInc1:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsInc1
case 71 : //"sprmCDxaSpace"
case 96 : //"sprmCDxaSpace"
case NS_sprm::LN_CDxaSpace: // sprmCDxaSpace
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
//Kerning half point values
//TODO: there are two kerning values -
// in ww8par6.cxx NS_sprm::LN_CHpsKern is used as boolean AutoKerning
rContext->Insert(PROP_CHAR_CHAR_KERNING, true, uno::makeAny( sal_Int16(ConversionHelper::convertTwipToMM100(sal_Int16(nIntValue))) ) );
break;
case NS_sprm::LN_CHpsKern: // sprmCHpsKern auto kerning is bound to a minimum font size in Word - but not in Writer :-(
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_AUTO_KERNING, true, uno::makeAny( true ) );
break;
case NS_sprm::LN_CMajority50:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCMajority50
case NS_sprm::LN_CHpsMul:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCHpsMul
case NS_sprm::LN_CYsri:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCYsri
case NS_sprm::LN_CRgFtc0: // sprmCRgFtc0 //ascii font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc1: // sprmCRgFtc1 //Asian font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgFtc2: // sprmCRgFtc2 //CTL font index
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CFtcBi: // sprmCFtcBi //font index of a CTL font
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
FontTablePtr pFontTable = m_pImpl->GetFontTable();
if(nIntValue >= 0 && pFontTable->size() > sal_uInt32(nIntValue))
{
PropertyIds eFontName = PROP_CHAR_FONT_NAME;
PropertyIds eFontStyle = PROP_CHAR_FONT_STYLE;
PropertyIds eFontFamily = PROP_CHAR_FONT_FAMILY;
PropertyIds eFontCharSet = PROP_CHAR_FONT_CHAR_SET;
PropertyIds eFontPitch = PROP_CHAR_FONT_PITCH;
switch(nSprmId)
{
case NS_sprm::LN_CRgFtc0:
//already initialized
break;
case NS_sprm::LN_CRgFtc1:
eFontName = PROP_CHAR_FONT_NAME_ASIAN;
eFontStyle = PROP_CHAR_FONT_STYLE_ASIAN;
eFontFamily = PROP_CHAR_FONT_FAMILY_ASIAN;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_ASIAN;
eFontPitch = PROP_CHAR_FONT_PITCH_ASIAN;
break;
case NS_sprm::LN_CRgFtc2:
case NS_sprm::LN_CFtcBi:
eFontName = PROP_CHAR_FONT_NAME_COMPLEX;
eFontStyle = PROP_CHAR_FONT_STYLE_COMPLEX;
eFontFamily = PROP_CHAR_FONT_FAMILY_COMPLEX;
eFontCharSet = PROP_CHAR_FONT_CHAR_SET_COMPLEX;
eFontPitch = PROP_CHAR_FONT_PITCH_COMPLEX;
break;
}
const FontEntry::Pointer_t pFontEntry(pFontTable->getFontEntry(sal_uInt32(nIntValue)));
rContext->Insert(eFontName, true, uno::makeAny( pFontEntry->sFontName ));
// rContext->Insert(eFontStyle, uno::makeAny( pFontEntry-> ));
// rContext->Insert(eFontFamily, uno::makeAny( pFontEntry-> ));
rContext->Insert(eFontCharSet, true, uno::makeAny( (sal_Int16)pFontEntry->nTextEncoding ));
rContext->Insert(eFontPitch, true, uno::makeAny( pFontEntry->nPitchRequest ));
}
}
break;
case NS_sprm::LN_CCharScale: // sprmCCharScale
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
rContext->Insert(PROP_CHAR_SCALE_WIDTH, true,
uno::makeAny( sal_Int16(nIntValue) ));
break;
case NS_sprm::LN_CFImprint: // sprmCFImprint 1 or 0
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
// FontRelief: NONE, EMBOSSED, ENGRAVED
rContext->Insert(PROP_CHAR_RELIEF, true,
uno::makeAny( nIntValue ? awt::FontRelief::ENGRAVED : awt::FontRelief::NONE ));
break;
case NS_sprm::LN_CFObj:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFObj
case NS_sprm::LN_CPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCPropRMark
case NS_sprm::LN_CSfxText:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// The file-format has many character animations. We have only
// one, so we use it always. Suboptimal solution though.
if (nIntValue)
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( true ));
else
rContext->Insert(PROP_CHAR_FLASH, true, uno::makeAny( false ));
break; // sprmCSfxText
case NS_sprm::LN_CFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFBiDi
case NS_sprm::LN_CFDiacColor:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFDiacColor
case NS_sprm::LN_CIcoBi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIcoBi
case NS_sprm::LN_CDispFldRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDispFldRMark
case NS_sprm::LN_CIbstRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIbstRMarkDel
case NS_sprm::LN_CDttmRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCDttmRMarkDel
case NS_sprm::LN_CBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCBrc
case NS_sprm::LN_CShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCShd
case NS_sprm::LN_CIdslRMarkDel:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCIdslRMarkDel
case NS_sprm::LN_CFUsePgsuSettings:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCFUsePgsuSettings
case NS_sprm::LN_CCpg:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmCCpg
case NS_sprm::LN_CLidBi: // sprmCLidBi language complex
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid0_80: //sprmCRgLid0_80
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 1 */
//undocumented but interpreted as western language
case NS_sprm::LN_CRgLid0: // sprmCRgLid0 language Western
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
case NS_sprm::LN_CRgLid1: // sprmCRgLid1 language Asian
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
lang::Locale aLocale;
MsLangId::convertLanguageToLocale( (LanguageType)nIntValue, aLocale );
rContext->Insert(NS_sprm::LN_CRgLid0 == nSprmId ? PROP_CHAR_LOCALE :
NS_sprm::LN_CRgLid1 == nSprmId ? PROP_CHAR_LOCALE_ASIAN : PROP_CHAR_LOCALE_COMPLEX,
true,
uno::makeAny( aLocale ) );
}
break;
case NS_sprm::LN_CIdctHint: // sprmCIdctHint
//list table - text offset???
break;
case NS_sprm::LN_PicBrcl:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcl
case NS_sprm::LN_PicScale:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicScale
case NS_sprm::LN_PicBrcTop:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcTop
case NS_sprm::LN_PicBrcLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcLeft
case NS_sprm::LN_PicBrcBottom:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcBoConversionHelper::convertTwipToMM100ttom
case NS_sprm::LN_PicBrcRight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmPicBrcRight
case NS_sprm::LN_ScnsPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmScnsPgn
case NS_sprm::LN_SiHeadingPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSiHeadingPgn
case NS_sprm::LN_SOlstAnm:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSOlstAnm
case 136:
case NS_sprm::LN_SDxaColWidth: // sprmSDxaColWidth
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// contains the twip width of the column as 3-byte-code
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnWidth( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case NS_sprm::LN_SDxaColSpacing: // sprmSDxaColSpacing
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// the lowet byte contains the index
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->AppendColumnSpacing( ConversionHelper::convertTwipToMM100( (nIntValue & 0xffff00) >> 8 ));
break;
case 138:
case NS_sprm::LN_SFEvenlySpaced:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetEvenlySpaced( nIntValue > 0 );
break; // sprmSFEvenlySpaced
case NS_sprm::LN_SFProtected: // sprmSFProtected
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
//todo: missing feature - unlocked sections in protected documents
break;
case NS_sprm::LN_SDmBinFirst: // sprmSDmBinFirst
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetFirstPaperBin(nIntValue);
break;
case NS_sprm::LN_SDmBinOther: // sprmSDmBinOther
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPaperBin( nIntValue );
break;
case NS_sprm::LN_SBkc: // sprmSBkc
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
/* break type
0 - No break
1 - New Colunn
2 - New page
3 - Even page
4 - odd page
*/
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBreakType( nIntValue );
break;
case 143:
case NS_sprm::LN_SFTitlePage: // sprmSFTitlePage
case NS_ooxml::LN_EG_SectPrContents_titlePg:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTitlePage( nIntValue > 0 ? true : false );//section has title page
}
break;
case 144:
case NS_sprm::LN_SCcolumns: // sprmSCcolumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//no of columns - 1
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnCount( (sal_Int16) nIntValue );
break;
case 145:
case NS_sprm::LN_SDxaColumns: // sprmSDxaColumns
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//column distance - default 708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetColumnDistance( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case NS_sprm::LN_SFAutoPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFAutoPgn
case 147:
case NS_sprm::LN_SNfcPgn: // sprmSNfcPgn
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
//page numbering 0 - Arab, 1 - ROMAN, 2 - roman, 3 - ABC, 4 abc
sal_Int16 nNumbering;
switch( nIntValue )
{
case 1: nNumbering = style::NumberingType::ROMAN_UPPER;
case 2: nNumbering = style::NumberingType::ROMAN_LOWER;
case 3: nNumbering = style::NumberingType::CHARS_UPPER_LETTER;
case 4: nNumbering = style::NumberingType::CHARS_LOWER_LETTER;
case 0:
default:
nNumbering = style::NumberingType::ARABIC;
}
rContext->Insert( PROP_NUMBERING_TYPE, false, uno::makeAny( nNumbering ) );
break;
case NS_sprm::LN_SDyaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDyaPgn
case NS_sprm::LN_SDxaPgn:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSDxaPgn
case 150:
case NS_sprm::LN_SFPgnRestart: // sprmSFPgnRestart
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNoRestart( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFEndnote:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFEndnote
case 154:
case NS_sprm::LN_SNLnnMod:// sprmSNLnnMod
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMod( nIntValue );
break;
case 155:
case NS_sprm::LN_SDxaLnn: // sprmSDxaLnn
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetdxaLnn( nIntValue );
break;
case 152:
case NS_sprm::LN_SLnc:// sprmSLnc
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnc( nIntValue );
break;
case 160:
case NS_sprm::LN_SLnnMin: // sprmSLnnMin
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if( pSectionContext )
pSectionContext->SetLnnMin( nIntValue );
break;
case NS_sprm::LN_SGprfIhdt:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
//flags about header/footer sharing and footnotes?
/* ww8scan.hxx:
* WW8_HEADER_EVEN = 0x01, WW8_HEADER_ODD = 0x02, WW8_FOOTER_EVEN = 0x04,
* WW8_FOOTER_ODD = 0x08, WW8_HEADER_FIRST = 0x10, WW8_FOOTER_FIRST = 0x20
*/
// if(pSectionContext)
break; // sprmSGprfIhdt
case NS_sprm::LN_SDyaHdrTop: // sprmSDyaHdrTop
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderTop( ConversionHelper::convertTwipToMM100( nIntValue ));
break;
case NS_sprm::LN_SDyaHdrBottom: // sprmSDyaHdrBottom
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
// default 720 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetHeaderBottom( ConversionHelper::convertTwipToMM100( nIntValue ) );
break;
case 158:
case NS_sprm::LN_SLBetween: // sprmSLBetween
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSeparatorLine( nIntValue > 0 );
break;
case NS_sprm::LN_SVjc:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSVjc
case 161:
case NS_sprm::LN_SPgnStart: // sprmSPgnStart
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page number
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetPageNumber( nIntValue );
break;
case 162:
case NS_sprm::LN_SBOrientation:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//todo: the old filter assumed that a value of 2 points to double-pages layout
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetLandscape( nIntValue > 0 );
rContext->Insert( PROP_IS_LANDSCAPE , false, uno::makeAny( nIntValue > 0 ));
break; // sprmSBOrientation
case NS_sprm::LN_SBCustomize:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break; // sprmSBCustomize
case 165:
case NS_sprm::LN_SYaPage: // sprmSYaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page height, rounded to default values, default: 0x3dc0 twip
sal_Int32 nHeight = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_HEIGHT, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nHeight ) ) );
}
break;
case NS_sprm::LN_SXaPage: // sprmSXaPage
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//page width, rounded to default values, default 0x2fd0 twip
sal_Int32 nWidth = ConversionHelper::convertTwipToMM100( nIntValue );
rContext->Insert( PROP_WIDTH, false, uno::makeAny( PaperInfo::sloppyFitPageDimension( nWidth ) ) );
}
break;
case 166:
case NS_sprm::LN_SDxaLeft: // sprmSDxaLeft
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//left page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetLeftMargin( nConverted );
rContext->Insert( PROP_LEFT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 167:
case NS_sprm::LN_SDxaRight: // sprmSDxaRight
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//right page margin default 0x708 twip
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( nIntValue );
if(pSectionContext)
pSectionContext->SetRightMargin( nConverted );
rContext->Insert( PROP_RIGHT_MARGIN, false, uno::makeAny( nConverted ));
}
break;
case 168:
case NS_sprm::LN_SDyaTop: // sprmSDyaTop
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//top page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_TOP_MARGIN, false, uno::makeAny( nConverted ) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetTopMargin( nConverted );
}
break;
case 169:
case NS_sprm::LN_SDyaBottom: // sprmSDyaBottom
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//bottom page margin default 1440 twip
//todo: check cast of SVBT16
sal_Int32 nConverted = ConversionHelper::convertTwipToMM100( static_cast< sal_Int16 >( nIntValue ) );
rContext->Insert( PROP_BOTTOM_MARGIN, false, uno::makeAny( nConverted) );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetBottomMargin( nConverted );
}
break;
case 170:
case NS_sprm::LN_SDzaGutter: // sprmSDzaGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// gutter is added to one of the margins of a section depending on RTL, can be placed on top either
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDzaGutter( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case NS_sprm::LN_SDmPaperReq: // sprmSDmPaperReq
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
//paper code - no handled in old filter
break;
case NS_sprm::LN_SPropRMark:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSPropRMark
case NS_sprm::LN_SFBiDi:// sprmSFBiDi
{
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetSFBiDi( nIntValue > 0 );
}
break;
case NS_sprm::LN_SFFacingCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmSFFacingCol
case NS_sprm::LN_SFRTLGutter: // sprmSFRTLGutter
{
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->SetGutterRTL( nIntValue > 0 );
}
break;
case NS_sprm::LN_SBrcTop: // sprmSBrcTop
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcLeft: // sprmSBrcLeft
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcBottom: // sprmSBrcBottom
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_sprm::LN_SBrcRight: // sprmSBrcRight
/* WRITERFILTERSTATUS: Sectiondone: 100, planned: 0.5, spent: 0 */
{
table::BorderLine aBorderLine;
sal_Int32 nLineDistance = ConversionHelper::MakeBorderLine( nIntValue, aBorderLine );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
static const BorderPosition aPositions[4] =
{
BORDER_TOP,
BORDER_LEFT,
BORDER_BOTTOM,
BORDER_RIGHT
};
pSectionContext->SetBorder( aPositions[nSprmId - NS_sprm::LN_SBrcTop], nLineDistance, aBorderLine );
}
}
break;
case NS_sprm::LN_SPgbProp: // sprmSPgbProp
{
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->ApplyBorderToPageStyles( m_pImpl->GetPageStyles(), m_pImpl->GetTextFactory(), nIntValue );
}
}
break;
case NS_sprm::LN_SDxtCharSpace:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetDxtCharSpace( nIntValue );
}
}
break; // sprmSDxtCharSpace
case NS_sprm::LN_SDyaLinePitch: // sprmSDyaLinePitch
{
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//see SwWW8ImplReader::SetDocumentGrid
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->SetGridLinePitch( ConversionHelper::convertTwipToMM100( nIntValue ) );
}
}
break;
case 0x703a: //undocumented, grid related?
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
OSL_ENSURE( false, "TODO: not handled yet"); //nIntValue like 0x008a2373 ?
break;
case NS_sprm::LN_SClm:
{
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
sal_Int16 nGridType = text::TextGridMode::NONE;
switch( nIntValue )
{
case 0:
nGridType = text::TextGridMode::NONE;
break;
case 3:
//Text snaps to char grid, this doesn't make a lot of sense to
//me. This is closer than LINES_CHARS
nGridType = text::TextGridMode::LINES;
break;
case 1:
nGridType = text::TextGridMode::LINES_AND_CHARS;
break;
case 2:
nGridType = text::TextGridMode::LINES;
break;
default:;
}
rContext->Insert( PROP_GRID_MODE, false, uno::makeAny( nGridType ) );
//Seems to force this behaviour in word ?
if(nGridType != text::TextGridMode::NONE)
m_pImpl->SetDocumentSettingsProperty(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_ADD_EXTERNAL_LEADING ),
uno::makeAny( true ) );
}
break; // sprmSClm
case NS_sprm::LN_STextFlow:
case NS_ooxml::LN_EG_SectPrContents_textDirection:
/* WRITERFILTERSTATUS: done: 100, planned: 2, spent: 0 */
{
/* 0 HoriLR 1 Vert TR 2 Vert TR 3 Vert TT 4 HoriLT
only 0 and 1 can be imported correctly
*/
sal_Int16 nDirection = text::WritingMode_LR_TB;
switch( nIntValue )
{
case 0:
case 4:
nDirection = text::WritingMode_LR_TB;
break;
case 1:
case 2:
case 3:
nDirection = text::WritingMode_TB_RL;
break;
default:;
}
PropertyMap * pTargetContext = rContext.get();
if (pSectionContext != NULL &&
nSprmId == NS_ooxml::LN_EG_SectPrContents_textDirection)
{
pTargetContext = pSectionContext;
}
pTargetContext->Insert(PROP_WRITING_MODE, false, uno::makeAny( nDirection ) );
}
break; // sprmSTextFlow
case NS_sprm::LN_TJc: // sprmTJc
case NS_sprm::LN_TDxaLeft:
case NS_sprm::LN_TDxaGapHalf:
case NS_sprm::LN_TFCantSplit:
case NS_sprm::LN_TTableHeader:
case NS_sprm::LN_TTableBorders: // sprmTTableBorders
{
OSL_ENSURE( false, "table propeties should be handled by the table manager");
}
break;
case NS_sprm::LN_TDefTable10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable10
case NS_sprm::LN_TDyaRowHeight:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDyaRowHeight
case NS_sprm::LN_TDefTable:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTable
case NS_sprm::LN_TDefTableShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDefTableShd
case NS_sprm::LN_TTlp:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTlp
case NS_sprm::LN_TFBiDi:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTFBiDi
case NS_sprm::LN_THTMLProps:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTHTMLProps
case NS_sprm::LN_TSetBrc:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc
case NS_sprm::LN_TInsert:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTInsert
case NS_sprm::LN_TDelete:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDelete
case NS_sprm::LN_TDxaCol:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDxaCol
case NS_sprm::LN_TMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTMerge
case NS_sprm::LN_TSplit:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSplit
case NS_sprm::LN_TSetBrc10:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetBrc10
case 164: // sprmTSetShd
case NS_sprm::LN_TSetShd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShd
case NS_sprm::LN_TSetShdOdd:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTSetShdOdd
case NS_sprm::LN_TTextFlow:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTTextFlow
case NS_sprm::LN_TDiagLine:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTDiagLine
case NS_sprm::LN_TVertMerge:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertMerge
case NS_sprm::LN_TVertAlign:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; // sprmTVertAlign
// the following are not part of the official documentation
case 0x6870: //TxtForeColor
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
//contains a color as 0xTTRRGGBB while SO uses 0xTTRRGGBB
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x4874:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //seems to be a language id for Asian text - undocumented
case 0x6877: //underlining color
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int32 nColor = ConversionHelper::ConvertColor(nIntValue);
rContext->Insert(PROP_CHAR_UNDERLINE_HAS_COLOR, true, uno::makeAny( true ) );
rContext->Insert(PROP_CHAR_UNDERLINE_COLOR, true, uno::makeAny( nColor ) );
}
break;
case 0x6815:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case NS_sprm::LN_CIndrsid:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x6467:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xF617:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0xd634: // sprmTNewSpacing - table spacing ( see WW8TabBandDesc::ProcessSpacing() )
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break;
case NS_sprm::LN_TTRLeft:
/* WRITERFILTERSTATUS: done: 0, planned: 2, spent: 0 */
break; //undocumented
case 0x4888:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0x6887:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//properties of list levels - undocumented
break;
case 0xd234:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd235:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd236:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
case 0xd237:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;//undocumented section properties
case NS_sprm::LN_CEastAsianLayout:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_CT_Tabs_tab:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
m_pImpl->IncorporateTabStop(m_pImpl->m_aCurrentTabStop);
m_pImpl->m_aCurrentTabStop = DeletableTabStop();
break;
case NS_ooxml::LN_CT_PPrBase_tabs:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
// Initialize tab stop vector from style sheet
if( !m_pImpl->IsStyleSheetImport() )
{
uno::Any aValue = m_pImpl->GetPropertyFromStyleSheet(PROP_PARA_TAB_STOPS);
uno::Sequence< style::TabStop > aStyleTabStops;
if(aValue >>= aStyleTabStops)
{
m_pImpl->InitTabStopFromStyle( aStyleTabStops );
}
}
resolveSprmProps(rSprm);
rContext->Insert(PROP_PARA_TAB_STOPS, true, uno::makeAny( m_pImpl->GetCurrentTabStopAndClear()));
}
break;
case NS_ooxml::LN_CT_PPr_sectPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_color:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_rFonts:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_bdr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_eastAsianLayout:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_u:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_RPrBase_lang:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_spacing:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_ind:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_RPrDefault_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrDefault_pPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_pPrDefault:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_DocDefaults_rPrDefault:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_pPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_Style_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPr_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_PPrBase_numPr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_footnotePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_SectPrContents_endnotePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->SetInFootnoteProperties( NS_ooxml::LN_EG_SectPrContents_footnotePr == nSprmId );
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_lnNumType:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);
LineNumberSettings aSettings = m_pImpl->GetLineNumberSettings();
aSettings.bIsOn = true;
m_pImpl->SetLineNumberSettings( aSettings );
//apply settings at XLineNumberingProperties
try
{
uno::Reference< text::XLineNumberingProperties > xLineNumberingProperties( m_pImpl->GetTextDocument(), uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySet > xLineNumberingPropSet = xLineNumberingProperties->getLineNumberingProperties();
PropertyNameSupplier& rNameSupplier = PropertyNameSupplier::GetPropertyNameSupplier();
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_IS_ON ), uno::makeAny(true) );
if( aSettings.nInterval )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_INTERVAL ), uno::makeAny((sal_Int16)aSettings.nInterval) );
if( aSettings.nDistance )
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_DISTANCE ), uno::makeAny(aSettings.nDistance) );
xLineNumberingPropSet->setPropertyValue(rNameSupplier.GetName( PROP_RESTART_AT_EACH_PAGE ), uno::makeAny(aSettings.bRestartAtEachPage) );
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_CT_PPrBase_framePr:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pContext.get() )
{
ParagraphPropertyMap* pParaContext = dynamic_cast< ParagraphPropertyMap* >( pContext.get() );
pParaContext->SetFrameMode();
}
else
{
//TODO: What about style sheet import of frame properties
}
resolveSprmProps(rSprm);
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgSz:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
CT_PageSz.code = 0;
{
PaperInfo aLetter(PAPER_LETTER);
CT_PageSz.w = aLetter.getWidth();
CT_PageSz.h = aLetter.getHeight();
}
CT_PageSz.orient = false;
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
pSectionContext->Insert( PROP_HEIGHT, false, uno::makeAny( CT_PageSz.h ) );
pSectionContext->Insert( PROP_IS_LANDSCAPE, false, uno::makeAny( CT_PageSz.orient ));
pSectionContext->Insert( PROP_WIDTH, false, uno::makeAny( CT_PageSz.w ) );
pSectionContext->SetLandscape( CT_PageSz.orient );
}
break;
case NS_ooxml::LN_EG_SectPrContents_pgMar:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
m_pImpl->InitPageMargins();
resolveSprmProps(rSprm);
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
{
const _PageMar& rPageMar = m_pImpl->GetPageMargins();
pSectionContext->SetTopMargin( rPageMar.top );
pSectionContext->SetRightMargin( rPageMar.right );
pSectionContext->SetBottomMargin( rPageMar.bottom );
pSectionContext->SetLeftMargin( rPageMar.left );
pSectionContext->SetHeaderTop( rPageMar.header );
pSectionContext->SetHeaderBottom( rPageMar.footer );
}
break;
case NS_ooxml::LN_EG_SectPrContents_cols:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
SectionColumnHandlerPtr pSectHdl( new SectionColumnHandler );
pProperties->resolve(*pSectHdl);
if(pSectionContext)
{
if( pSectHdl->IsEqualWidth() )
{
pSectionContext->SetEvenlySpaced( true );
pSectionContext->SetColumnCount( (sal_Int16) (pSectHdl->GetNum() - 1) );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( !pSectHdl->GetColumns().empty() )
{
pSectionContext->SetEvenlySpaced( false );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
pSectionContext->SetColumnCount( (sal_Int16)(pSectHdl->GetColumns().size() -1));
std::vector<_Column>::const_iterator tmpIter = pSectHdl->GetColumns().begin();
for (; tmpIter != pSectHdl->GetColumns().end(); tmpIter++)
{
pSectionContext->AppendColumnWidth( tmpIter->nWidth );
if ((tmpIter != pSectHdl->GetColumns().end() - 1) || (tmpIter->nSpace > 0))
pSectionContext->AppendColumnSpacing( tmpIter->nSpace );
}
pSectionContext->SetSeparatorLine( pSectHdl->IsSeparator() );
}
else if( pSectHdl->GetNum() > 0 )
{
pSectionContext->SetColumnCount( (sal_Int16)pSectHdl->GetNum() - 1 );
pSectionContext->SetColumnDistance( pSectHdl->GetSpace() );
}
}
}
}
break;
case NS_ooxml::LN_EG_SectPrContents_docGrid:
resolveSprmProps(rSprm);
break;
case NS_ooxml::LN_EG_SectPrContents_pgBorders:
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get( ) && pSectionContext )
{
PageBordersHandlerPtr pHandler( new PageBordersHandler );
pProperties->resolve( *pHandler );
// Set the borders to the context and apply them to the styles
pHandler->SetBorders( pSectionContext );
pSectionContext->SetBorderParams( pHandler->GetDisplayOffset( ) );
}
}
break;
case NS_ooxml::LN_CT_PPrBase_pStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
m_pImpl->SetCurrentParaStyleId( sStringValue );
StyleSheetTablePtr pStyleTable = m_pImpl->GetStyleSheetTable();
const ::rtl::OUString sConvertedStyleName = pStyleTable->ConvertStyleName( sStringValue, true );
if (m_pImpl->GetTopContext() && m_pImpl->GetTopContextType() != CONTEXT_SECTION)
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sConvertedStyleName ));
const StyleSheetEntryPtr pEntry = pStyleTable->FindStyleSheetByISTD(sStringValue);
//apply numbering to paragraph if it was set at the style
OSL_ENSURE( pEntry.get(), "no style sheet found" );
const StyleSheetPropertyMap* pStyleSheetProperties = dynamic_cast<const StyleSheetPropertyMap*>(pEntry ? pEntry->pProperties.get() : 0);
if( pStyleSheetProperties && pStyleSheetProperties->GetListId() >= 0 )
rContext->Insert( PROP_NUMBERING_STYLE_NAME, true, uno::makeAny(
m_pImpl->GetListTable( )->GetStyleName( pStyleSheetProperties->GetListId( ) ) ), false);
if( pStyleSheetProperties && pStyleSheetProperties->GetListLevel() >= 0 )
rContext->Insert( PROP_NUMBERING_LEVEL, true, uno::makeAny(pStyleSheetProperties->GetListLevel()), false);
}
break;
case NS_ooxml::LN_EG_RPrBase_rStyle:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
rtl::OUString sConvertedName( m_pImpl->GetStyleSheetTable()->ConvertStyleName( sStringValue, true ) );
// First check if the style exists in the document.
StyleSheetEntryPtr pEntry = m_pImpl->GetStyleSheetTable( )->FindStyleSheetByStyleName( sConvertedName );
bool bExists = pEntry.get( ) && ( pEntry->nStyleTypeCode == STYLE_TYPE_CHAR );
// Add the property if the style exists
if ( bExists && m_pImpl->GetTopContext() )
m_pImpl->GetTopContext()->Insert( PROP_CHAR_STYLE_NAME, true, uno::makeAny( sConvertedName ) );
}
break;
case NS_ooxml::LN_CT_TblPrBase_tblCellMar: //cell margins
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
resolveSprmProps(rSprm);//contains LN_CT_TblCellMar_top, LN_CT_TblCellMar_left, LN_CT_TblCellMar_bottom, LN_CT_TblCellMar_right
}
break;
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: done: 100, planned: 0, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
MeasureHandlerPtr pMeasureHandler( new MeasureHandler );
pProperties->resolve(*pMeasureHandler);
sal_Int32 nMeasureValue = pMeasureHandler->getMeasureValue();
PropertyIds eId = META_PROP_CELL_MAR_TOP;
switch(nSprmId)
{
case NS_ooxml::LN_CT_TblCellMar_top:
/* WRITERFILTERSTATUS: */
break;
case NS_ooxml::LN_CT_TblCellMar_left:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_LEFT;
break;
case NS_ooxml::LN_CT_TblCellMar_bottom:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_BOTTOM;
break;
case NS_ooxml::LN_CT_TblCellMar_right:
/* WRITERFILTERSTATUS: */
eId = META_PROP_CELL_MAR_RIGHT;
break;
default:;
}
rContext->Insert( eId, false, uno::makeAny(nMeasureValue), false);
}
}
break;
case NS_sprm::LN_CFNoProof: //0x875 no grammar and spell checking, unsupported
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_ooxml::LN_anchor_anchor: // at_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_inline_inline: // as_character drawing
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
{
GraphicImportType eGraphicType =
(NS_ooxml::LN_anchor_anchor ==
sal::static_int_cast<Id>(nSprmId)) ?
IMPORT_AS_DETECTED_ANCHOR :
IMPORT_AS_DETECTED_INLINE;
GraphicImportPtr pGraphicImport =
m_pImpl->GetGraphicImport(eGraphicType);
pProperties->resolve(*pGraphicImport);
m_pImpl->ImportGraphic(pProperties, eGraphicType);
if( !pGraphicImport->IsGraphic() )
{
m_pImpl->ResetGraphicImport();
// todo: It's a shape, now start shape import
}
}
}
break;
case NS_ooxml::LN_EG_RPrBase_vertAlign:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
sal_Int16 nEscapement = 0;
sal_Int8 nProp = 58;
if( sStringValue.equalsAscii( "superscript" ))
nEscapement = 101;
else if( sStringValue.equalsAscii( "subscript" ))
nEscapement = -101;
else
nProp = 100;
rContext->Insert(PROP_CHAR_ESCAPEMENT, true, uno::makeAny( nEscapement ) );
rContext->Insert(PROP_CHAR_ESCAPEMENT_HEIGHT, true, uno::makeAny( nProp ) );
}
break;
// case NS_ooxml::LN_CT_FtnEdn_type
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnEdn_id
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_EG_FtnEdnNumProps_numRestart
case NS_ooxml::LN_CT_FtnProps_pos:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
//footnotes in word can be at page end or beneath text - writer supports only the first
//endnotes in word can be at section end or document end - writer supports only the latter
// -> so this property can be ignored
break;
case NS_ooxml::LN_EG_FtnEdnNumProps_numStart:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_FtnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_CT_EdnProps_numFmt:
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
{
try
{
uno::Reference< beans::XPropertySet > xFtnEdnSettings;
if( m_pImpl->IsInFootnoteProperties() )
{
uno::Reference< text::XFootnotesSupplier> xFootnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xFootnotesSupplier->getFootnoteSettings();
}
else
{
uno::Reference< text::XEndnotesSupplier> xEndnotesSupplier( m_pImpl->GetTextDocument(), uno::UNO_QUERY );
xFtnEdnSettings = xEndnotesSupplier->getEndnoteSettings();
}
if( NS_ooxml::LN_EG_FtnEdnNumProps_numStart == nSprmId )
{
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_START_AT),
uno::makeAny( sal_Int16( nIntValue - 1 )));
}
else
{
sal_Int16 nNumType = ConversionHelper::ConvertNumberingType( nIntValue );
xFtnEdnSettings->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName( PROP_NUMBERING_TYPE),
uno::makeAny( nNumType ));
}
}
catch( const uno::Exception& )
{
}
}
break;
case NS_ooxml::LN_paratrackchange:
m_pImpl->StartParaChange( );
case NS_ooxml::LN_trackchange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
case NS_ooxml::LN_EG_RPrContent_rPrChange:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
{
m_pImpl->AddNewRedline( );
resolveSprmProps( rSprm );
// now the properties author, date and id should be available
sal_Int32 nToken = m_pImpl->GetCurrentRedlineToken();
switch( nToken & 0xffff )
{
case ooxml::OOXML_mod :
case ooxml::OOXML_ins :
case ooxml::OOXML_del : break;
default: OSL_ENSURE( false, "redline token other than mod, ins or del" );
}
m_pImpl->EndParaChange( );
}
break;
case NS_ooxml::LN_CT_RPrChange_rPr:
/* WRITERFILTERSTATUS: done: 100, planned: 5, spent: 0 */
break;
/* WRITERFILTERSTATUS: done: 0, planned: 4, spent: 0 */
case NS_ooxml::LN_object:
{
#if DEBUG
clog << "DomainMapper: LN_object" << endl;
#endif
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get( ) )
{
OLEHandlerPtr pOLEHandler( new OLEHandler );
pProperties->resolve(*pOLEHandler);
if ( pOLEHandler->isOLEObject( ) )
{
::rtl::OUString sStreamName = pOLEHandler->copyOLEOStream( m_pImpl->GetTextDocument() );
if( sStreamName.getLength() )
{
m_pImpl->appendOLE( sStreamName, pOLEHandler );
}
}
}
}
break;
// case NS_ooxml::LN_CT_EdnProps_pos
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnProps_numFmt
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_FtnDocProps_footnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// case NS_ooxml::LN_CT_EdnDocProps_endnote
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//break;
case NS_ooxml::LN_EG_HdrFtrReferences_headerReference: // header reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
case NS_ooxml::LN_EG_HdrFtrReferences_footerReference: // footer reference - not needed
/* WRITERFILTERSTATUS: done: 100, planned: 0.5, spent: 0 */
break;
case NS_ooxml::LN_EG_RPrBase_snapToGrid: // "Use document grid settings for inter-paragraph spacing"
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
break;
case NS_sprm::LN_PContextualSpacing:
//TODO: determines whether top/bottom paragraph spacing is added if equal styles are following - unsupported
break;
case NS_ooxml::LN_EG_SectPrContents_formProt: //section protection, only form editing is enabled - unsupported
case NS_ooxml::LN_EG_SectPrContents_vAlign:
case NS_ooxml::LN_EG_RPrBase_fitText:
case NS_ooxml::LN_EG_RPrBase_shd:
/* WRITERFILTERSTATUS: done: 0, planned: 0, spent: 0 */
break;
case NS_ooxml::LN_CT_Lvl_pStyle:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//TODO: numbering style should apply current numbering level - not yet supported
break;
default:
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("unhandled");
dmapper_logger->attribute("id", nSprmId);
dmapper_logger->endElement("unhandled");
#endif
}
}
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("sprm");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::entry(int /*pos*/,
writerfilter::Reference<Properties>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("entry");
#endif
ref->resolve(*this);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("entry");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::data(const sal_uInt8* /*buf*/, size_t /*len*/,
writerfilter::Reference<Properties>::Pointer_t /*ref*/)
{
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startSectionGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("section");
#endif
m_pImpl->PushProperties(CONTEXT_SECTION);
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endSectionGroup()
{
PropertyMapPtr pContext = m_pImpl->GetTopContextOfType(CONTEXT_SECTION);
SectionPropertyMap* pSectionContext = dynamic_cast< SectionPropertyMap* >( pContext.get() );
OSL_ENSURE(pSectionContext, "SectionContext unavailable!");
if(pSectionContext)
pSectionContext->CloseSectionGroup( *m_pImpl );
m_pImpl->PopProperties(CONTEXT_SECTION);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("section");
#endif
}
/*-- 09.06.2006 09:52:13---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startParagraphGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("paragraph");
#endif
m_pImpl->getTableManager().startParagraphGroup();
m_pImpl->PushProperties(CONTEXT_PARAGRAPH);
static ::rtl::OUString sDefault( ::rtl::OUString::createFromAscii("Standard") );
if (m_pImpl->GetTopContext())
{
m_pImpl->GetTopContext()->Insert( PROP_PARA_STYLE_NAME, true, uno::makeAny( sDefault ) );
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
}
m_pImpl->clearDeferredBreaks();
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endParagraphGroup()
{
//handle unprocessed deferred breaks
PropertyMapPtr pParaProperties = m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH);
if( pParaProperties->hasEmptyPropertyValues() )
{
PropertyMap::const_iterator aIter = pParaProperties->find(PropertyDefinition( PROP_BREAK_TYPE , false ) );
if( aIter != pParaProperties->end() )
{
style::BreakType eType;
aIter->second >>= eType;
bool bPage = false;
bool bColumn = false;
if( eType == style::BreakType_PAGE_BEFORE )
bPage = true;
else if( eType == style::BreakType_COLUMN_BEFORE )
bColumn = true;
if( bPage || bColumn )
{
try
{
uno::Reference< beans::XPropertySet > xRangeProperties( m_pImpl->GetTopTextAppend()->getEnd(), uno::UNO_QUERY_THROW );
xRangeProperties->setPropertyValue(
PropertyNameSupplier::GetPropertyNameSupplier().GetName(PROP_BREAK_TYPE),
uno::makeAny( bPage ? style::BreakType_PAGE_BEFORE : style::BreakType_COLUMN_BEFORE));
}
catch( const uno::Exception& )
{
}
}
}
}
m_pImpl->PopProperties(CONTEXT_PARAGRAPH);
m_pImpl->getTableManager().endParagraphGroup();
//frame conversion has to be executed after table conversion
m_pImpl->ExecuteFrameConversion();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("paragraph");
#endif
}
void DomainMapper::startShape( uno::Reference< drawing::XShape > xShape )
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("shape");
#endif
m_pImpl->PushShapeContext( xShape );
}
void DomainMapper::endShape( )
{
m_pImpl->PopShapeContext( );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("shape");
#endif
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushStyleSheetProperties( PropertyMapPtr pStyleProperties, bool bAffectTableMngr )
{
m_pImpl->PushStyleProperties( pStyleProperties );
if ( bAffectTableMngr )
m_pImpl->getTableManager( ).SetStyleProperties( pStyleProperties );
}
/*-- 13.06.2007 16:15:55---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopStyleSheetProperties( bool bAffectTableMngr )
{
m_pImpl->PopProperties( CONTEXT_STYLESHEET );
if ( bAffectTableMngr )
{
PropertyMapPtr emptyPtr;
m_pImpl->getTableManager( ).SetStyleProperties( emptyPtr );
}
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PushListProperties( ::boost::shared_ptr<PropertyMap> pListProperties )
{
m_pImpl->PushListProperties( pListProperties );
}
/*-- 28.01.2008 14:52:33---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::PopListProperties()
{
m_pImpl->PopProperties( CONTEXT_LIST );
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::startCharacterGroup()
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("charactergroup");
#endif
m_pImpl->PushProperties(CONTEXT_CHARACTER);
DomainMapperTableManager& rTableManager = m_pImpl->getTableManager();
if( rTableManager.getTableStyleName().getLength() )
{
PropertyMapPtr pTopContext = m_pImpl->GetTopContext();
rTableManager.CopyTextProperties(pTopContext, m_pImpl->GetStyleSheetTable());
}
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::endCharacterGroup()
{
m_pImpl->PopProperties(CONTEXT_CHARACTER);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("charactergroup");
#endif
}
/*-- 09.06.2006 09:52:14---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::text(const sal_uInt8 * data_, size_t len)
{
//TODO: Determine the right text encoding (FIB?)
::rtl::OUString sText( (const sal_Char*) data_, len, RTL_TEXTENCODING_MS_1252 );
try
{
if(len == 1)
{
switch(*data_)
{
case 0x02: return; //footnote character
case 0x0c: //page break
m_pImpl->deferBreak(PAGE_BREAK);
return;
case 0x0e: //column break
m_pImpl->deferBreak(COLUMN_BREAK);
return;
case 0x07:
m_pImpl->getTableManager().text(data_, len);
case 0x0d:
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
return;
case 0x13:
m_pImpl->PushFieldContext();
return;
case 0x14:
// delimiter not necessarily available
// appears only if field contains further content
m_pImpl->CloseFieldCommand();
return;
case 0x15: /* end of field */
m_pImpl->PopFieldContext();
return;
default:
break;
}
}
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
if( pContext->GetFootnote().is() && m_pImpl->IsCustomFtnMark() )
{
pContext->GetFootnote()->setLabel( sText );
m_pImpl->SetCustomFtnMark( false );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
{
//--> debug
//sal_uInt32 nSize = pContext->size();
//<--
if (pContext == NULL)
pContext.reset(new PropertyMap());
m_pImpl->appendTextPortion( sText, pContext );
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("text");
dmapper_logger->chars(sText);
dmapper_logger->endElement("text");
#endif
}
}
catch( const uno::RuntimeException& )
{
std::clog << __FILE__ << "(l" << __LINE__ << ")" << std::endl;
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::utext(const sal_uInt8 * data_, size_t len)
{
OUString sText;
OUStringBuffer aBuffer = OUStringBuffer(len);
aBuffer.append( (const sal_Unicode *) data_, len);
sText = aBuffer.makeStringAndClear();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("utext");
dmapper_logger->chars(sText);
dmapper_logger->endElement("utext");
#endif
try
{
m_pImpl->getTableManager().utext(data_, len);
if(len == 1 && ((*data_) == 0x0d || (*data_) == 0x07))
m_pImpl->finishParagraph(m_pImpl->GetTopContextOfType(CONTEXT_PARAGRAPH));
else
{
PropertyMapPtr pContext = m_pImpl->GetTopContext();
if ( pContext && !pContext->GetFootnote().is() )
{
if (m_pImpl->isBreakDeferred(PAGE_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_PAGE_BEFORE) );
else if (m_pImpl->isBreakDeferred(COLUMN_BREAK))
m_pImpl->GetTopContext()->Insert( PROP_BREAK_TYPE, true, uno::makeAny( com::sun::star::style::BreakType_COLUMN_BEFORE) );
m_pImpl->clearDeferredBreaks();
}
/* doesn't seem to be working
if( pContext->GetFootnote().is() )
{
//todo: the check for 0x0a is a hack!
if( *data_ != 0x0a && !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else */
if( pContext && pContext->GetFootnote().is() )
{
if( !pContext->GetFootnoteSymbol() )
pContext->GetFootnote()->setLabel( sText );
//otherwise ignore sText
}
else if( m_pImpl->IsOpenFieldCommand() )
m_pImpl->AppendFieldCommand(sText);
else if( m_pImpl->IsOpenField() && m_pImpl->IsFieldResultAsString())
/*depending on the success of the field insert operation this result will be
set at the field or directly inserted into the text*/
m_pImpl->SetFieldResult( sText );
else
{
if (pContext == NULL)
pContext.reset(new PropertyMap());
m_pImpl->appendTextPortion( sText, pContext );
}
}
}
catch( const uno::RuntimeException& )
{
}
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::props(writerfilter::Reference<Properties>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("props");
#endif
string sType = ref->getType();
if( sType == "PICF" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_GRAPHIC);
}
else if( sType == "FSPA" )
{
m_pImpl->ImportGraphic(ref, IMPORT_AS_SHAPE);
}
else
ref->resolve(*this);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("props");
#endif
}
/*-- 09.06.2006 09:52:15---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::table(Id name, writerfilter::Reference<Table>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("table");
dmapper_logger->attribute("id", (*QNameToString::Instance())(name));
#endif
// printf ( "DomainMapper::table(0x%.4x)\n", (unsigned int)name);
m_pImpl->SetAnyTableImport(true);
/* WRITERFILTERSTATUS: table: attributedata */
switch(name)
{
case NS_rtf::LN_FONTTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
// create a font table object that listens to the attributes
// each entry call inserts a new font entry
ref->resolve( *m_pImpl->GetFontTable() );
break;
case NS_rtf::LN_STYLESHEET:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//same as above to import style sheets
m_pImpl->SetStyleSheetImport( true );
ref->resolve( *m_pImpl->GetStyleSheetTable() );
m_pImpl->GetStyleSheetTable()->ApplyStyleSheets(m_pImpl->GetFontTable());
m_pImpl->SetStyleSheetImport( false );
break;
case NS_ooxml::LN_NUMBERING:
case NS_rtf::LN_LISTTABLE:
{
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
//the same for list tables
ref->resolve( *m_pImpl->GetListTable() );
m_pImpl->GetListTable( )->CreateNumberingRules( );
}
break;
case NS_rtf::LN_LFOTABLE:
/* WRITERFILTERSTATUS: done: 0, planned: 0.5, spent: 0 */
ref->resolve( *m_pImpl->GetLFOTable() );
break;
case NS_ooxml::LN_THEMETABLE:
ref->resolve ( *m_pImpl->GetThemeTable() );
break;
case NS_ooxml::LN_settings_settings:
ref->resolve ( *m_pImpl->GetSettingsTable() );
m_pImpl->ApplySettingsTable();
break;
default:
OSL_ENSURE( false, "which table is to be filled here?");
}
m_pImpl->SetAnyTableImport(false);
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("table");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::substream(Id rName, ::writerfilter::Reference<Stream>::Pointer_t ref)
{
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->startElement("substream");
#endif
m_pImpl->getTableManager().startLevel();
//->debug
//string sName = (*QNameToString::Instance())(rName);
//--<debug
//import of page header/footer
/* WRITERFILTERSTATUS: table: attributedata */
switch( rName )
{
case NS_rtf::LN_headerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_headerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_headerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageHeader(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footerl:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_LEFT);
break;
case NS_rtf::LN_footerr:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_RIGHT);
break;
case NS_rtf::LN_footerf:
/* WRITERFILTERSTATUS: done: 50, planned: 2, spent: 0 */
m_pImpl->PushPageFooter(SectionPropertyMap::PAGE_FIRST);
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PushFootOrEndnote( NS_rtf::LN_footnote == rName );
break;
case NS_rtf::LN_annotation :
m_pImpl->PushAnnotation();
break;
}
ref->resolve(*this);
switch( rName )
{
case NS_rtf::LN_headerl:
case NS_rtf::LN_headerr:
case NS_rtf::LN_headerf:
case NS_rtf::LN_footerl:
case NS_rtf::LN_footerr:
case NS_rtf::LN_footerf:
m_pImpl->PopPageHeaderFooter();
break;
case NS_rtf::LN_footnote:
case NS_rtf::LN_endnote:
m_pImpl->PopFootOrEndnote();
break;
case NS_rtf::LN_annotation :
m_pImpl->PopAnnotation();
break;
}
m_pImpl->getTableManager().endLevel();
#ifdef DEBUG_DOMAINMAPPER
dmapper_logger->endElement("substream");
#endif
}
/*-- 09.06.2006 09:52:16---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::info(const string & /*info_*/)
{
}
void DomainMapper::handleUnderlineType(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext)
{
sal_Int16 eUnderline = awt::FontUnderline::NONE;
switch(nIntValue)
{
case 0: eUnderline = awt::FontUnderline::NONE; break;
case 2: pContext->Insert(PROP_CHAR_WORD_MODE, true, uno::makeAny( true ) ); // TODO: how to get rid of it?
case 1: eUnderline = awt::FontUnderline::SINGLE; break;
case 3: eUnderline = awt::FontUnderline::DOUBLE; break;
case 4: eUnderline = awt::FontUnderline::DOTTED; break;
case 7: eUnderline = awt::FontUnderline::DASH; break;
case 9: eUnderline = awt::FontUnderline::DASHDOT; break;
case 10:eUnderline = awt::FontUnderline::DASHDOTDOT; break;
case 6: eUnderline = awt::FontUnderline::BOLD; break;
case 11:eUnderline = awt::FontUnderline::WAVE; break;
case 20:eUnderline = awt::FontUnderline::BOLDDOTTED; break;
case 23:eUnderline = awt::FontUnderline::BOLDDASH; break;
case 39:eUnderline = awt::FontUnderline::LONGDASH; break;
case 55:eUnderline = awt::FontUnderline::BOLDLONGDASH; break;
case 25:eUnderline = awt::FontUnderline::BOLDDASHDOT; break;
case 26:eUnderline = awt::FontUnderline::BOLDDASHDOTDOT;break;
case 27:eUnderline = awt::FontUnderline::BOLDWAVE; break;
case 43:eUnderline = awt::FontUnderline::DOUBLEWAVE; break;
default: ;
}
pContext->Insert(PROP_CHAR_UNDERLINE, true, uno::makeAny( eUnderline ) );
}
void DomainMapper::handleParaJustification(const sal_Int32 nIntValue, const ::boost::shared_ptr<PropertyMap> pContext, const bool bExchangeLeftRight)
{
sal_Int16 nAdjust = 0;
sal_Int16 nLastLineAdjust = 0;
switch(nIntValue)
{
case 1:
nAdjust = style::ParagraphAdjust_CENTER;
break;
case 2:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_LEFT : style::ParagraphAdjust_RIGHT);
break;
case 4:
nLastLineAdjust = style::ParagraphAdjust_BLOCK;
//no break;
case 3:
nAdjust = style::ParagraphAdjust_BLOCK;
break;
case 0:
default:
nAdjust = static_cast< sal_Int16 > (bExchangeLeftRight ? style::ParagraphAdjust_RIGHT : style::ParagraphAdjust_LEFT);
break;
}
pContext->Insert( PROP_PARA_ADJUST, true, uno::makeAny( nAdjust ) );
pContext->Insert( PROP_PARA_LAST_LINE_ADJUST, true, uno::makeAny( nLastLineAdjust ) );
}
bool DomainMapper::getColorFromIndex(const sal_Int32 nIndex, sal_Int32 &nColor)
{
nColor = 0;
if ((nIndex < 1) || (nIndex > 16))
return false;
switch (nIndex)
{
case 1: nColor=0x000000; break; //black
case 2: nColor=0x0000ff; break; //blue
case 3: nColor=0x00ffff; break; //cyan
case 4: nColor=0x00ff00; break; //green
case 5: nColor=0xff00ff; break; //magenta
case 6: nColor=0xff0000; break; //red
case 7: nColor=0xffff00; break; //yellow
case 8: nColor=0xffffff; break; //white
case 9: nColor=0x000080; break;//dark blue
case 10: nColor=0x008080; break; //dark cyan
case 11: nColor=0x008000; break; //dark green
case 12: nColor=0x800080; break; //dark magenta
case 13: nColor=0x800000; break; //dark red
case 14: nColor=0x808000; break; //dark yellow
case 15: nColor=0x808080; break; //dark gray
case 16: nColor=0xC0C0C0; break; //light gray
default:
return false;
}
return true;
}
sal_Int16 DomainMapper::getEmphasisValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1:
return com::sun::star::text::FontEmphasis::DOT_ABOVE;
case 2:
return com::sun::star::text::FontEmphasis::ACCENT_ABOVE;
case 3:
return com::sun::star::text::FontEmphasis::CIRCLE_ABOVE;
case 4:
return com::sun::star::text::FontEmphasis::DOT_BELOW;
default:
return com::sun::star::text::FontEmphasis::NONE;
}
}
rtl::OUString DomainMapper::getBracketStringFromEnum(const sal_Int32 nIntValue, const bool bIsPrefix)
{
switch(nIntValue)
{
case 1:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "(" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ")" ));
case 2:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "[" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "]" ));
case 3:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "<" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ">" ));
case 4:
if (bIsPrefix)
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "{" ));
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "}" ));
case 0:
default:
return rtl::OUString();
}
}
void DomainMapper::resolveSprmProps(Sprm & rSprm)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = rSprm.getProps();
if( pProperties.get())
pProperties->resolve(*this);
}
void DomainMapper::resolveAttributeProperties(Value & val)
{
writerfilter::Reference<Properties>::Pointer_t pProperties = val.getProperties();
if( pProperties.get())
pProperties->resolve(*this);
}
com::sun::star::style::TabAlign DomainMapper::getTabAlignFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 0:
case 4: // bar not supported
return com::sun::star::style::TabAlign_LEFT;
case 1:
return com::sun::star::style::TabAlign_CENTER;
case 2:
return com::sun::star::style::TabAlign_RIGHT;
case 3:
return com::sun::star::style::TabAlign_DECIMAL;
default:
return com::sun::star::style::TabAlign_DEFAULT;
}
return com::sun::star::style::TabAlign_LEFT;
}
sal_Unicode DomainMapper::getFillCharFromValue(const sal_Int32 nIntValue)
{
switch (nIntValue)
{
case 1: // dot
return sal_Unicode(0x002e);
case 2: // hyphen
return sal_Unicode(0x002d);
case 3: // underscore
case 4: // heavy FIXME ???
return sal_Unicode(0x005f);
case NS_ooxml::LN_Value_ST_TabTlc_middleDot: // middleDot
return sal_Unicode(0x00b7);
case 0: // none
default:
return sal_Unicode(0x0020); // blank space
}
}
/*-- 18.07.2007 14:59:00---------------------------------------------------
-----------------------------------------------------------------------*/
bool DomainMapper::IsOOXMLImport() const
{
return m_pImpl->IsOOXMLImport();
}
/*-- 18.07.2007 16:03:14---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference < lang::XMultiServiceFactory > DomainMapper::GetTextFactory() const
{
return m_pImpl->GetTextFactory();
}
/*-- 12.11.2007 10:41:01---------------------------------------------------
-----------------------------------------------------------------------*/
void DomainMapper::AddListIDToLFOTable( sal_Int32 nAbstractNumId )
{
m_pImpl->GetLFOTable()->AddListID( nAbstractNumId );
}
/*-- 31.01.2008 18:19:44---------------------------------------------------
-----------------------------------------------------------------------*/
uno::Reference< text::XTextRange > DomainMapper::GetCurrentTextRange()
{
return m_pImpl->GetTopTextAppend()->getEnd();
}
/*-- 05.02.2008 10:26:26---------------------------------------------------
-----------------------------------------------------------------------*/
::rtl::OUString DomainMapper::getOrCreateCharStyle( PropertyValueVector_t& rCharProperties )
{
StyleSheetTablePtr pStyleSheets = m_pImpl->GetStyleSheetTable();
return pStyleSheets->getOrCreateCharStyle( rCharProperties );
}
} //namespace dmapper
} //namespace writerfilter
|
#include "GUI.h"
using namespace sf;
using namespace Chess;
namespace GUI {
GUI::GUI(int width, int height, Board& board) : board(board) {
this->width = width;
this->height = height;
window = new RenderWindow(VideoMode(width, height), "Ninja Chess");
window->setVerticalSyncEnabled(true);
font.loadFromFile("Resources/stchess.ttf");
text.setFont(font);
text.setCharacterSize(height / 8);
text.setColor(Color::Black);
notationMap['P'] = "A";
notationMap['p'] = "a";
notationMap['R'] = "D";
notationMap['r'] = "d";
notationMap['N'] = "B";
notationMap['n'] = "b";
notationMap['B'] = "C";
notationMap['b'] = "c";
notationMap['Q'] = "E";
notationMap['q'] = "e";
notationMap['K'] = "F";
notationMap['k'] = "f";
}
GUI::~GUI() {
delete window;
}
bool GUI::isOpen() const {
return window->isOpen();
}
void GUI::update() {
Event event;
while (window->pollEvent(event)) {
if (event.type == Event::Closed)
window->close();
}
bool pressed = Mouse::isButtonPressed(Mouse::Left);
if (pressed && !mousePressed) {
Vector2i mousePos = Mouse::getPosition(*window);
Position tempPos(mousePos.x * 8 / width, mousePos.y * 8 / height);
if (tempPos.valid()) {
if (board.getPiece(tempPos) != nullptr) {
selection = tempPos;
selected = true;
}
}
}
mousePressed = pressed;
}
void GUI::render() {
window->clear();
drawBoard();
drawPieces();
window->display();
}
void GUI::drawBoard() {
Color brightSquare(224, 217, 190);
Color darkSquare(152, 145, 135);
RectangleShape square(Vector2f(width / 8.f, height / 8.f));
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
square.setPosition(x * width / 8.f, y * height / 8.f);
if (selected && selection == Position(x, y))
square.setFillColor(Color::Yellow);
else if ((x + y) % 2 == 0)
square.setFillColor(brightSquare);
else
square.setFillColor(darkSquare);
window->draw(square);
}
}
}
void GUI::drawPieces() {
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
Piece* piece = board.getPiece(Position(x, 7-y));
if (piece != nullptr) {
text.setPosition(Vector2f(x * width / 8.f, (y - 0.2f) * width / 8.f));
text.setString(notationMap[piece->notation()]);
window->draw(text);
}
}
}
}
}
Move pieces
#include "GUI.h"
using namespace sf;
using namespace Chess;
namespace GUI {
GUI::GUI(int width, int height, Board& board) : board(board) {
this->width = width;
this->height = height;
window = new RenderWindow(VideoMode(width, height), "Ninja Chess");
window->setVerticalSyncEnabled(true);
font.loadFromFile("Resources/stchess.ttf");
text.setFont(font);
text.setCharacterSize(height / 8);
text.setColor(Color::Black);
notationMap['P'] = "A";
notationMap['p'] = "a";
notationMap['R'] = "D";
notationMap['r'] = "d";
notationMap['N'] = "B";
notationMap['n'] = "b";
notationMap['B'] = "C";
notationMap['b'] = "c";
notationMap['Q'] = "E";
notationMap['q'] = "e";
notationMap['K'] = "F";
notationMap['k'] = "f";
}
GUI::~GUI() {
delete window;
}
bool GUI::isOpen() const {
return window->isOpen();
}
void GUI::update() {
Event event;
while (window->pollEvent(event)) {
if (event.type == Event::Closed)
window->close();
}
bool pressed = Mouse::isButtonPressed(Mouse::Left);
if (pressed && !mousePressed) {
Vector2i mousePos = Mouse::getPosition(*window);
Position tempPos(mousePos.x * 8 / width, mousePos.y * 8 / height);
tempPos.y = 7 - tempPos.y;
if (tempPos.valid()) {
if (selected) {
Piece* selectedPiece = board.getPiece(selection);
if (selectedPiece->isLegal(board, tempPos)) {
board.move(selection, tempPos);
selected = false;
} else if (board.getPiece(tempPos) != nullptr) {
selection = tempPos;
selected = true;
}
} else if (board.getPiece(tempPos) != nullptr) {
selection = tempPos;
selected = true;
}
}
}
mousePressed = pressed;
}
void GUI::render() {
window->clear();
drawBoard();
drawPieces();
window->display();
}
void GUI::drawBoard() {
Color brightSquare(224, 217, 190);
Color darkSquare(152, 145, 135);
RectangleShape square(Vector2f(width / 8.f, height / 8.f));
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
square.setPosition(x * width / 8.f, y * height / 8.f);
if (selected && selection == Position(x, 7-y))
square.setFillColor(Color::Yellow);
else if ((x + y) % 2 == 0)
square.setFillColor(brightSquare);
else
square.setFillColor(darkSquare);
window->draw(square);
}
}
}
void GUI::drawPieces() {
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
Piece* piece = board.getPiece(Position(x, 7-y));
if (piece != nullptr) {
text.setPosition(Vector2f(x * width / 8.f, (y - 0.2f) * width / 8.f));
text.setString(notationMap[piece->notation()]);
window->draw(text);
}
}
}
}
} |
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <cxxabi.h>
#ifndef _GLIBCXX_CDTOR_CALLABI // new in GCC 4.7 cxxabi.h
#define _GLIBCXX_CDTOR_CALLABI
#endif
#include <boost/unordered_map.hpp>
#include <sal/log.hxx>
#include <rtl/instance.hxx>
#include <rtl/strbuf.hxx>
#include <rtl/ustrbuf.hxx>
#include <osl/diagnose.h>
#include <osl/mutex.hxx>
#include <com/sun/star/uno/genfunc.hxx>
#include "com/sun/star/uno/RuntimeException.hpp"
#include <typelib/typedescription.hxx>
#include <uno/any2.h>
#include "share.hxx"
using namespace ::std;
using namespace ::osl;
using namespace ::rtl;
using namespace ::com::sun::star::uno;
using namespace ::__cxxabiv1;
namespace CPPU_CURRENT_NAMESPACE
{
#if MACOSX_SDK_VERSION >= 1070
// MacOSX10.4u.sdk/usr/include/c++/4.0.0/cxxabi.h defined
// __cxxabiv1::__class_type_info and __cxxabiv1::__si_class_type_info but
// MacOSX10.7.sdk/usr/include/cxxabi.h no longer does, so instances of those
// classes need to be created manually:
// std::type_info defined in <typeinfo> offers a protected ctor:
struct FAKE_type_info: public std::type_info {
FAKE_type_info(char const * name): type_info(name) {}
};
// Modeled after __cxxabiv1::__si_class_type_info defined in
// MacOSX10.4u.sdk/usr/include/c++/4.0.0/cxxabi.h (i.e.,
// abi::__si_class_type_info documented at
// <http://www.codesourcery.com/public/cxx-abi/abi.html#rtti>):
struct FAKE_si_class_type_info: public FAKE_type_info {
FAKE_si_class_type_info(char const * name, std::type_info const * theBase):
FAKE_type_info(name), base(theBase) {}
std::type_info const * base;
// actually a __cxxabiv1::__class_type_info pointer
};
struct Base {};
struct Derived: Base {};
std::type_info * create_FAKE_class_type_info(char const * name) {
std::type_info * p = new FAKE_type_info(name);
// cxxabiv1::__class_type_info has no data members in addition to
// std::type_info
*reinterpret_cast< void ** >(p) = *reinterpret_cast< void * const * >(
&typeid(Base));
// copy correct __cxxabiv1::__class_type_info vtable into place
return p;
}
std::type_info * create_FAKE_si_class_type_info(
char const * name, std::type_info const * base)
{
std::type_info * p = new FAKE_si_class_type_info(name, base);
*reinterpret_cast< void ** >(p) = *reinterpret_cast< void * const * >(
&typeid(Derived));
// copy correct __cxxabiv1::__si_class_type_info vtable into place
return p;
}
#endif
//==================================================================================================
static OUString toUNOname( char const * p ) SAL_THROW(())
{
#if OSL_DEBUG_LEVEL > 1
char const * start = p;
#endif
// example: N3com3sun4star4lang24IllegalArgumentExceptionE
OUStringBuffer buf( 64 );
OSL_ASSERT( 'N' == *p );
++p; // skip N
while ('E' != *p)
{
// read chars count
long n = (*p++ - '0');
while ('0' <= *p && '9' >= *p)
{
n *= 10;
n += (*p++ - '0');
}
buf.appendAscii( p, n );
p += n;
if ('E' != *p)
buf.append( (sal_Unicode)'.' );
}
#if OSL_DEBUG_LEVEL > 1
OUString ret( buf.makeStringAndClear() );
OString c_ret( OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ) );
fprintf( stderr, "> toUNOname(): %s => %s\n", start, c_ret.getStr() );
return ret;
#else
return buf.makeStringAndClear();
#endif
}
//==================================================================================================
class RTTI
{
typedef boost::unordered_map< OUString, type_info *, OUStringHash > t_rtti_map;
Mutex m_mutex;
t_rtti_map m_rttis;
t_rtti_map m_generatedRttis;
void * m_hApp;
public:
RTTI() SAL_THROW(());
~RTTI() SAL_THROW(());
type_info * getRTTI( typelib_CompoundTypeDescription * ) SAL_THROW(());
};
//__________________________________________________________________________________________________
RTTI::RTTI() SAL_THROW(())
#if defined(FREEBSD) && __FreeBSD_version < 702104
: m_hApp( dlopen( 0, RTLD_NOW | RTLD_GLOBAL ) )
#else
: m_hApp( dlopen( 0, RTLD_LAZY ) )
#endif
{
}
//__________________________________________________________________________________________________
RTTI::~RTTI() SAL_THROW(())
{
dlclose( m_hApp );
}
//__________________________________________________________________________________________________
type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THROW(())
{
type_info * rtti;
OUString const & unoName = *(OUString const *)&pTypeDescr->aBase.pTypeName;
MutexGuard guard( m_mutex );
t_rtti_map::const_iterator iFind( m_rttis.find( unoName ) );
if (iFind == m_rttis.end())
{
// RTTI symbol
OStringBuffer buf( 64 );
buf.append( "_ZTIN" );
sal_Int32 index = 0;
do
{
OUString token( unoName.getToken( 0, '.', index ) );
buf.append( token.getLength() );
OString c_token( OUStringToOString( token, RTL_TEXTENCODING_ASCII_US ) );
buf.append( c_token );
}
while (index >= 0);
buf.append( 'E' );
OString symName( buf.makeStringAndClear() );
#if defined(FREEBSD) && __FreeBSD_version < 702104 /* #i22253# */
rtti = (type_info *)dlsym( RTLD_DEFAULT, symName.getStr() );
#else
rtti = (type_info *)dlsym( m_hApp, symName.getStr() );
#endif
if (rtti)
{
pair< t_rtti_map::iterator, bool > insertion (
m_rttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
SAL_WARN_IF( !insertion.second, "bridges", "key " << unoName << " already in rtti map" );
}
else
{
// try to lookup the symbol in the generated rtti map
t_rtti_map::const_iterator iFind2( m_generatedRttis.find( unoName ) );
if (iFind2 == m_generatedRttis.end())
{
// we must generate it !
// symbol and rtti-name is nearly identical,
// the symbol is prefixed with _ZTI
char const * rttiName = symName.getStr() +4;
#if OSL_DEBUG_LEVEL > 1
fprintf( stderr,"generated rtti for %s\n", rttiName );
#endif
if (pTypeDescr->pBaseTypeDescription)
{
// ensure availability of base
type_info * base_rtti = getRTTI(
(typelib_CompoundTypeDescription *)pTypeDescr->pBaseTypeDescription );
#if MACOSX_SDK_VERSION < 1070
rtti = new __si_class_type_info(
strdup( rttiName ), (__class_type_info *)base_rtti );
#else
rtti = create_FAKE_si_class_type_info(
strdup( rttiName ), base_rtti );
#endif
}
else
{
// this class has no base class
#if MACOSX_SDK_VERSION < 1070
rtti = new __class_type_info( strdup( rttiName ) );
#else
rtti = create_FAKE_class_type_info( strdup( rttiName ) );
#endif
}
pair< t_rtti_map::iterator, bool > insertion (
m_generatedRttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
SAL_WARN_IF( !insertion.second, "bridges", "key " << unoName << " already in generated rtti map" );
}
else // taking already generated rtti
{
rtti = iFind2->second;
}
}
}
else
{
rtti = iFind->second;
}
return rtti;
}
//--------------------------------------------------------------------------------------------------
extern "C" {
static void _GLIBCXX_CDTOR_CALLABI deleteException( void * pExc )
{
__cxa_exception const * header = ((__cxa_exception const *)pExc - 1);
typelib_TypeDescription * pTD = 0;
OUString unoName( toUNOname( header->exceptionType->name() ) );
::typelib_typedescription_getByName( &pTD, unoName.pData );
OSL_ENSURE( pTD, "### unknown exception type! leaving out destruction => leaking!!!" );
if (pTD)
{
::uno_destructData( pExc, pTD, cpp_release );
::typelib_typedescription_release( pTD );
}
}
}
namespace
{
struct theRTTI : public rtl::Static<RTTI, theRTTI> {};
}
//==================================================================================================
void raiseException( uno_Any * pUnoExc, uno_Mapping * pUno2Cpp )
{
#if OSL_DEBUG_LEVEL > 1
OString cstr(
OUStringToOString(
*reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
RTL_TEXTENCODING_ASCII_US ) );
fprintf( stderr, "> uno exception occurred: %s\n", cstr.getStr() );
#endif
void * pCppExc;
type_info * rtti;
{
// construct cpp exception object
typelib_TypeDescription * pTypeDescr = 0;
TYPELIB_DANGER_GET( &pTypeDescr, pUnoExc->pType );
OSL_ASSERT( pTypeDescr );
if (! pTypeDescr)
{
throw RuntimeException(
OUString("cannot get typedescription for type ") +
*reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
Reference< XInterface >() );
}
pCppExc = __cxa_allocate_exception( pTypeDescr->nSize );
::uno_copyAndConvertData( pCppExc, pUnoExc->pData, pTypeDescr, pUno2Cpp );
// destruct uno exception
::uno_any_destruct( pUnoExc, 0 );
// avoiding locked counts
static RTTI * s_rtti = 0;
if (! s_rtti)
{
MutexGuard guard( Mutex::getGlobalMutex() );
if (! s_rtti)
{
#ifdef LEAK_STATIC_DATA
s_rtti = new RTTI();
#else
static RTTI rtti_data;
s_rtti = &rtti_data;
#endif
}
}
rtti = (type_info *)s_rtti->getRTTI( (typelib_CompoundTypeDescription *) pTypeDescr );
TYPELIB_DANGER_RELEASE( pTypeDescr );
OSL_ENSURE( rtti, "### no rtti for throwing exception!" );
if (! rtti)
{
throw RuntimeException(
OUString("no rtti for type ") +
*reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
Reference< XInterface >() );
}
}
__cxa_throw( pCppExc, rtti, deleteException );
}
//==================================================================================================
void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping * pCpp2Uno )
{
if (! header)
{
RuntimeException aRE(
OUString("no exception header!"),
Reference< XInterface >() );
Type const & rType = ::getCppuType( &aRE );
uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
#if OSL_DEBUG_LEVEL > 0
OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );
OSL_FAIL( cstr.getStr() );
#endif
return;
}
typelib_TypeDescription * pExcTypeDescr = 0;
OUString unoName( toUNOname( header->exceptionType->name() ) );
#if OSL_DEBUG_LEVEL > 1
OString cstr_unoName( OUStringToOString( unoName, RTL_TEXTENCODING_ASCII_US ) );
fprintf( stderr, "> c++ exception occurred: %s\n", cstr_unoName.getStr() );
#endif
typelib_typedescription_getByName( &pExcTypeDescr, unoName.pData );
if (0 == pExcTypeDescr)
{
RuntimeException aRE(
OUString("exception type not found: ") + unoName,
Reference< XInterface >() );
Type const & rType = ::getCppuType( &aRE );
uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
#if OSL_DEBUG_LEVEL > 0
OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );
OSL_FAIL( cstr.getStr() );
#endif
}
else
{
// construct uno exception any
uno_any_constructAndConvert( pUnoExc, header->adjustedPtr, pExcTypeDescr, pCpp2Uno );
typelib_typedescription_release( pExcTypeDescr );
}
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Bypass dynamic type_info generation for now when using libc++
The type_info crack is even harder in the libc++ (with Clang, on OS X)
case, sigh. Punt for now and let's see what happens...
Change-Id: I17c3a4d9d933acfbf554649c9ec8b6fb5213f2f0
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
#include <cxxabi.h>
#ifndef _GLIBCXX_CDTOR_CALLABI // new in GCC 4.7 cxxabi.h
#define _GLIBCXX_CDTOR_CALLABI
#endif
#include <boost/unordered_map.hpp>
#include <sal/log.hxx>
#include <rtl/instance.hxx>
#include <rtl/strbuf.hxx>
#include <rtl/ustrbuf.hxx>
#include <osl/diagnose.h>
#include <osl/mutex.hxx>
#include <com/sun/star/uno/genfunc.hxx>
#include "com/sun/star/uno/RuntimeException.hpp"
#include <typelib/typedescription.hxx>
#include <uno/any2.h>
#include "share.hxx"
using namespace ::std;
using namespace ::osl;
using namespace ::rtl;
using namespace ::com::sun::star::uno;
using namespace ::__cxxabiv1;
namespace CPPU_CURRENT_NAMESPACE
{
#ifndef _LIBCPP_VERSION
#if MACOSX_SDK_VERSION >= 1070
// MacOSX10.4u.sdk/usr/include/c++/4.0.0/cxxabi.h defined
// __cxxabiv1::__class_type_info and __cxxabiv1::__si_class_type_info but
// MacOSX10.7.sdk/usr/include/cxxabi.h no longer does, so instances of those
// classes need to be created manually:
// std::type_info defined in <typeinfo> offers a protected ctor:
struct FAKE_type_info: public std::type_info {
FAKE_type_info(char const * name): type_info(name) {}
};
// Modeled after __cxxabiv1::__si_class_type_info defined in
// MacOSX10.4u.sdk/usr/include/c++/4.0.0/cxxabi.h (i.e.,
// abi::__si_class_type_info documented at
// <http://www.codesourcery.com/public/cxx-abi/abi.html#rtti>):
struct FAKE_si_class_type_info: public FAKE_type_info {
FAKE_si_class_type_info(char const * name, std::type_info const * theBase):
FAKE_type_info(name), base(theBase) {}
std::type_info const * base;
// actually a __cxxabiv1::__class_type_info pointer
};
struct Base {};
struct Derived: Base {};
std::type_info * create_FAKE_class_type_info(char const * name) {
std::type_info * p = new FAKE_type_info(name);
// cxxabiv1::__class_type_info has no data members in addition to
// std::type_info
*reinterpret_cast< void ** >(p) = *reinterpret_cast< void * const * >(
&typeid(Base));
// copy correct __cxxabiv1::__class_type_info vtable into place
return p;
}
std::type_info * create_FAKE_si_class_type_info(
char const * name, std::type_info const * base)
{
std::type_info * p = new FAKE_si_class_type_info(name, base);
*reinterpret_cast< void ** >(p) = *reinterpret_cast< void * const * >(
&typeid(Derived));
// copy correct __cxxabiv1::__si_class_type_info vtable into place
return p;
}
#endif
#endif
//==================================================================================================
static OUString toUNOname( char const * p ) SAL_THROW(())
{
#if OSL_DEBUG_LEVEL > 1
char const * start = p;
#endif
// example: N3com3sun4star4lang24IllegalArgumentExceptionE
OUStringBuffer buf( 64 );
OSL_ASSERT( 'N' == *p );
++p; // skip N
while ('E' != *p)
{
// read chars count
long n = (*p++ - '0');
while ('0' <= *p && '9' >= *p)
{
n *= 10;
n += (*p++ - '0');
}
buf.appendAscii( p, n );
p += n;
if ('E' != *p)
buf.append( (sal_Unicode)'.' );
}
#if OSL_DEBUG_LEVEL > 1
OUString ret( buf.makeStringAndClear() );
OString c_ret( OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US ) );
fprintf( stderr, "> toUNOname(): %s => %s\n", start, c_ret.getStr() );
return ret;
#else
return buf.makeStringAndClear();
#endif
}
//==================================================================================================
class RTTI
{
typedef boost::unordered_map< OUString, type_info *, OUStringHash > t_rtti_map;
Mutex m_mutex;
t_rtti_map m_rttis;
t_rtti_map m_generatedRttis;
void * m_hApp;
public:
RTTI() SAL_THROW(());
~RTTI() SAL_THROW(());
type_info * getRTTI( typelib_CompoundTypeDescription * ) SAL_THROW(());
};
//__________________________________________________________________________________________________
RTTI::RTTI() SAL_THROW(())
#if defined(FREEBSD) && __FreeBSD_version < 702104
: m_hApp( dlopen( 0, RTLD_NOW | RTLD_GLOBAL ) )
#else
: m_hApp( dlopen( 0, RTLD_LAZY ) )
#endif
{
}
//__________________________________________________________________________________________________
RTTI::~RTTI() SAL_THROW(())
{
dlclose( m_hApp );
}
//__________________________________________________________________________________________________
type_info * RTTI::getRTTI( typelib_CompoundTypeDescription *pTypeDescr ) SAL_THROW(())
{
type_info * rtti;
OUString const & unoName = *(OUString const *)&pTypeDescr->aBase.pTypeName;
MutexGuard guard( m_mutex );
t_rtti_map::const_iterator iFind( m_rttis.find( unoName ) );
if (iFind == m_rttis.end())
{
// RTTI symbol
OStringBuffer buf( 64 );
buf.append( "_ZTIN" );
sal_Int32 index = 0;
do
{
OUString token( unoName.getToken( 0, '.', index ) );
buf.append( token.getLength() );
OString c_token( OUStringToOString( token, RTL_TEXTENCODING_ASCII_US ) );
buf.append( c_token );
}
while (index >= 0);
buf.append( 'E' );
OString symName( buf.makeStringAndClear() );
#if defined(FREEBSD) && __FreeBSD_version < 702104 /* #i22253# */
rtti = (type_info *)dlsym( RTLD_DEFAULT, symName.getStr() );
#else
rtti = (type_info *)dlsym( m_hApp, symName.getStr() );
#endif
if (rtti)
{
pair< t_rtti_map::iterator, bool > insertion (
m_rttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
SAL_WARN_IF( !insertion.second, "bridges", "key " << unoName << " already in rtti map" );
}
else
{
// try to lookup the symbol in the generated rtti map
t_rtti_map::const_iterator iFind2( m_generatedRttis.find( unoName ) );
if (iFind2 == m_generatedRttis.end())
{
#ifndef _LIBCPP_VERSION
// we must generate it !
// symbol and rtti-name is nearly identical,
// the symbol is prefixed with _ZTI
char const * rttiName = symName.getStr() +4;
#if OSL_DEBUG_LEVEL > 1
fprintf( stderr,"generated rtti for %s\n", rttiName );
#endif
if (pTypeDescr->pBaseTypeDescription)
{
// ensure availability of base
type_info * base_rtti = getRTTI(
(typelib_CompoundTypeDescription *)pTypeDescr->pBaseTypeDescription );
#if MACOSX_SDK_VERSION < 1070
rtti = new __si_class_type_info(
strdup( rttiName ), (__class_type_info *)base_rtti );
#else
rtti = create_FAKE_si_class_type_info(
strdup( rttiName ), base_rtti );
#endif
}
else
{
// this class has no base class
#if MACOSX_SDK_VERSION < 1070
rtti = new __class_type_info( strdup( rttiName ) );
#else
rtti = create_FAKE_class_type_info( strdup( rttiName ) );
#endif
}
pair< t_rtti_map::iterator, bool > insertion (
m_generatedRttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
SAL_WARN_IF( !insertion.second, "bridges", "key " << unoName << " already in generated rtti map" );
#else
OSL_FAIL("Cannot generate type_infos with libc++, sigh");
return NULL;
#endif
}
else // taking already generated rtti
{
rtti = iFind2->second;
}
}
}
else
{
rtti = iFind->second;
}
return rtti;
}
//--------------------------------------------------------------------------------------------------
extern "C" {
static void _GLIBCXX_CDTOR_CALLABI deleteException( void * pExc )
{
__cxa_exception const * header = ((__cxa_exception const *)pExc - 1);
typelib_TypeDescription * pTD = 0;
OUString unoName( toUNOname( header->exceptionType->name() ) );
::typelib_typedescription_getByName( &pTD, unoName.pData );
OSL_ENSURE( pTD, "### unknown exception type! leaving out destruction => leaking!!!" );
if (pTD)
{
::uno_destructData( pExc, pTD, cpp_release );
::typelib_typedescription_release( pTD );
}
}
}
namespace
{
struct theRTTI : public rtl::Static<RTTI, theRTTI> {};
}
//==================================================================================================
void raiseException( uno_Any * pUnoExc, uno_Mapping * pUno2Cpp )
{
#if OSL_DEBUG_LEVEL > 1
OString cstr(
OUStringToOString(
*reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
RTL_TEXTENCODING_ASCII_US ) );
fprintf( stderr, "> uno exception occurred: %s\n", cstr.getStr() );
#endif
void * pCppExc;
type_info * rtti;
{
// construct cpp exception object
typelib_TypeDescription * pTypeDescr = 0;
TYPELIB_DANGER_GET( &pTypeDescr, pUnoExc->pType );
OSL_ASSERT( pTypeDescr );
if (! pTypeDescr)
{
throw RuntimeException(
OUString("cannot get typedescription for type ") +
*reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
Reference< XInterface >() );
}
pCppExc = __cxa_allocate_exception( pTypeDescr->nSize );
::uno_copyAndConvertData( pCppExc, pUnoExc->pData, pTypeDescr, pUno2Cpp );
// destruct uno exception
::uno_any_destruct( pUnoExc, 0 );
// avoiding locked counts
static RTTI * s_rtti = 0;
if (! s_rtti)
{
MutexGuard guard( Mutex::getGlobalMutex() );
if (! s_rtti)
{
#ifdef LEAK_STATIC_DATA
s_rtti = new RTTI();
#else
static RTTI rtti_data;
s_rtti = &rtti_data;
#endif
}
}
rtti = (type_info *)s_rtti->getRTTI( (typelib_CompoundTypeDescription *) pTypeDescr );
TYPELIB_DANGER_RELEASE( pTypeDescr );
OSL_ENSURE( rtti, "### no rtti for throwing exception!" );
if (! rtti)
{
throw RuntimeException(
OUString("no rtti for type ") +
*reinterpret_cast< OUString const * >( &pUnoExc->pType->pTypeName ),
Reference< XInterface >() );
}
}
__cxa_throw( pCppExc, rtti, deleteException );
}
//==================================================================================================
void fillUnoException( __cxa_exception * header, uno_Any * pUnoExc, uno_Mapping * pCpp2Uno )
{
if (! header)
{
RuntimeException aRE(
OUString("no exception header!"),
Reference< XInterface >() );
Type const & rType = ::getCppuType( &aRE );
uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
#if OSL_DEBUG_LEVEL > 0
OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );
OSL_FAIL( cstr.getStr() );
#endif
return;
}
typelib_TypeDescription * pExcTypeDescr = 0;
OUString unoName( toUNOname( header->exceptionType->name() ) );
#if OSL_DEBUG_LEVEL > 1
OString cstr_unoName( OUStringToOString( unoName, RTL_TEXTENCODING_ASCII_US ) );
fprintf( stderr, "> c++ exception occurred: %s\n", cstr_unoName.getStr() );
#endif
typelib_typedescription_getByName( &pExcTypeDescr, unoName.pData );
if (0 == pExcTypeDescr)
{
RuntimeException aRE(
OUString("exception type not found: ") + unoName,
Reference< XInterface >() );
Type const & rType = ::getCppuType( &aRE );
uno_type_any_constructAndConvert( pUnoExc, &aRE, rType.getTypeLibType(), pCpp2Uno );
#if OSL_DEBUG_LEVEL > 0
OString cstr( OUStringToOString( aRE.Message, RTL_TEXTENCODING_ASCII_US ) );
OSL_FAIL( cstr.getStr() );
#endif
}
else
{
// construct uno exception any
uno_any_constructAndConvert( pUnoExc, header->adjustedPtr, pExcTypeDescr, pCpp2Uno );
typelib_typedescription_release( pExcTypeDescr );
}
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: xmlservices.cxx,v $
* $Revision: 1.5 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include "precompiled_reportdesign.hxx"
#include <cppuhelper/factory.hxx>
#include <osl/diagnose.h>
#include <cppuhelper/implementationentry.hxx>
#include "xmlfilter.hxx"
#include "xmlExport.hxx"
#include "dbloader2.hxx"
#include "xmlExportDocumentHandler.hxx"
#include "xmlImportDocumentHandler.hxx"
/********************************************************************************************/
using namespace ::rptxml;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::registry;
/********************************************************************************************/
// registry functions
namespace
{
cppu::ImplementationEntry entries[] = {
{ &ORptFilter::create, &ORptFilter::getImplementationName_Static, &ORptFilter::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptTypeDetection::create, &ORptTypeDetection::getImplementationName_Static, &ORptTypeDetection::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ODBFullExportHelper::create, &ODBFullExportHelper::getImplementationName_Static, &ODBFullExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptExportHelper::create, &ORptExportHelper::getImplementationName_Static, &ORptExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptExport::create, &ORptExport::getImplementationName_Static, &ORptExport::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptContentExportHelper::create, &ORptContentExportHelper::getImplementationName_Static, &ORptContentExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptStylesExportHelper::create, &ORptStylesExportHelper::getImplementationName_Static, &ORptStylesExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptImportHelper::create, &ORptImportHelper::getImplementationName_Static, &ORptImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptContentImportHelper::create, &ORptContentImportHelper::getImplementationName_Static, &ORptContentImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptStylesImportHelper::create, &ORptStylesImportHelper::getImplementationName_Static, &ORptStylesImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ExportDocumentHandler::create, &ExportDocumentHandler::getImplementationName_Static, &ExportDocumentHandler::getSupportedServiceNames_static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ImportDocumentHandler::create, &ImportDocumentHandler::getImplementationName_Static, &ImportDocumentHandler::getSupportedServiceNames_static,
&cppu::createSingleComponentFactory, 0, 0 },
{ 0, 0, 0, 0, 0, 0 }
};
}
extern "C" void * SAL_CALL component_getFactory(
char const * implName, void * serviceManager, void * registryKey)
{
return cppu::component_getFactoryHelper(
implName, serviceManager, registryKey, entries);
}
extern "C" void SAL_CALL component_getImplementationEnvironment(
char const ** envTypeName, uno_Environment **)
{
*envTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
}
extern "C" sal_Bool SAL_CALL component_writeInfo(
void * serviceManager, void * registryKey)
{
return cppu::component_writeInfoHelper(
serviceManager, registryKey, entries);
}
INTEGRATION: CWS rptfix02 (1.5.42); FILE MERGED
2008/07/01 14:08:37 oj 1.5.42.1: #i91253# handle old version which do not have a meta.xml file
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: xmlservices.cxx,v $
* $Revision: 1.6 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include "precompiled_reportdesign.hxx"
#include <cppuhelper/factory.hxx>
#include <osl/diagnose.h>
#include <cppuhelper/implementationentry.hxx>
#include "xmlfilter.hxx"
#include "xmlExport.hxx"
#include "dbloader2.hxx"
#include "xmlExportDocumentHandler.hxx"
#include "xmlImportDocumentHandler.hxx"
/********************************************************************************************/
using namespace ::rptxml;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::registry;
/********************************************************************************************/
// registry functions
namespace
{
cppu::ImplementationEntry entries[] = {
{ &ORptFilter::create, &ORptFilter::getImplementationName_Static, &ORptFilter::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptTypeDetection::create, &ORptTypeDetection::getImplementationName_Static, &ORptTypeDetection::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ODBFullExportHelper::create, &ODBFullExportHelper::getImplementationName_Static, &ODBFullExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptExportHelper::create, &ORptExportHelper::getImplementationName_Static, &ORptExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptExport::create, &ORptExport::getImplementationName_Static, &ORptExport::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptContentExportHelper::create, &ORptContentExportHelper::getImplementationName_Static, &ORptContentExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptStylesExportHelper::create, &ORptStylesExportHelper::getImplementationName_Static, &ORptStylesExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptMetaExportHelper::create, &ORptMetaExportHelper::getImplementationName_Static, &ORptMetaExportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptImportHelper::create, &ORptImportHelper::getImplementationName_Static, &ORptImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptContentImportHelper::create, &ORptContentImportHelper::getImplementationName_Static, &ORptContentImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptStylesImportHelper::create, &ORptStylesImportHelper::getImplementationName_Static, &ORptStylesImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ExportDocumentHandler::create, &ExportDocumentHandler::getImplementationName_Static, &ExportDocumentHandler::getSupportedServiceNames_static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ImportDocumentHandler::create, &ImportDocumentHandler::getImplementationName_Static, &ImportDocumentHandler::getSupportedServiceNames_static,
&cppu::createSingleComponentFactory, 0, 0 },
{ &ORptMetaImportHelper::create, &ORptMetaImportHelper::getImplementationName_Static, &ORptMetaImportHelper::getSupportedServiceNames_Static,
&cppu::createSingleComponentFactory, 0, 0 },
{ 0, 0, 0, 0, 0, 0 }
};
}
extern "C" void * SAL_CALL component_getFactory(
char const * implName, void * serviceManager, void * registryKey)
{
return cppu::component_getFactoryHelper(
implName, serviceManager, registryKey, entries);
}
extern "C" void SAL_CALL component_getImplementationEnvironment(
char const ** envTypeName, uno_Environment **)
{
*envTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
}
extern "C" sal_Bool SAL_CALL component_writeInfo(
void * serviceManager, void * registryKey)
{
return cppu::component_writeInfoHelper(
serviceManager, registryKey, entries);
}
|
/*************************************************************************
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: javaoptions.cxx,v $
*
* $Revision: 1.11 $
*
* last change: $Author: obo $ $Date: 2006-09-17 03:39:46 $
*
* The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1.
*
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2005 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_codemaker.hxx"
#include <stdio.h>
#include <string.h>
#include "javaoptions.hxx"
#include "osl/process.h"
#include "osl/thread.h"
using namespace rtl;
sal_Bool JavaOptions::initOptions(int ac, char* av[], sal_Bool bCmdFile)
throw( IllegalArgument )
{
sal_Bool ret = sal_True;
sal_uInt16 i=0;
if (!bCmdFile)
{
bCmdFile = sal_True;
m_program = av[0];
if (ac < 2)
{
fprintf(stderr, "%s", prepareHelp().getStr());
ret = sal_False;
}
i = 1;
} else
{
i = 0;
}
char *s=NULL;
for( ; i < ac; i++)
{
if (av[i][0] == '-')
{
switch (av[i][1])
{
case 'O':
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-O', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
m_options["-O"] = OString(s);
break;
case 'B':
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-B', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
m_options["-B"] = OString(s);
break;
case 'n':
if (av[i][2] != 'D' || av[i][3] != '\0')
{
OString tmp("'-nD', please check");
tmp += " your input '" + OString(av[i]) + "'";
throw IllegalArgument(tmp);
}
m_options["-nD"] = OString("");
break;
case 'T':
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-T', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
if (m_options.count("-T") > 0)
{
OString tmp(m_options["-T"]);
tmp = tmp + ";" + s;
m_options["-T"] = tmp;
} else
{
m_options["-T"] = OString(s);
}
break;
case 'G':
if (av[i][2] == 'c')
{
if (av[i][3] != '\0')
{
OString tmp("'-Gc', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i]) + "'";
}
throw IllegalArgument(tmp);
}
m_options["-Gc"] = OString("");
break;
} else
if (av[i][2] != '\0')
{
OString tmp("'-G', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i]) + "'";
}
throw IllegalArgument(tmp);
}
m_options["-G"] = OString("");
break;
case 'X': // support for eXtra type rdbs
{
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-X', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
m_extra_input_files.push_back( s );
break;
}
default:
throw IllegalArgument("the option is unknown" + OString(av[i]));
}
} else
{
if (av[i][0] == '@')
{
FILE* cmdFile = fopen(av[i]+1, "r");
if( cmdFile == NULL )
{
fprintf(stderr, "%s", prepareHelp().getStr());
ret = sal_False;
} else
{
int rargc=0;
char* rargv[512];
char buffer[512];
while ( fscanf(cmdFile, "%s", buffer) != EOF )
{
rargv[rargc]= strdup(buffer);
rargc++;
}
fclose(cmdFile);
ret = initOptions(rargc, rargv, bCmdFile);
for (long j=0; j < rargc; j++)
{
free(rargv[j]);
}
}
} else
{
if (bCmdFile)
{
m_inputFiles.push_back(av[i]);
} else
{
OUString system_filepath;
if (osl_getCommandArg( i-1, &system_filepath.pData )
!= osl_Process_E_None)
{
OSL_ASSERT(false);
}
m_inputFiles.push_back(OUStringToOString(system_filepath, osl_getThreadTextEncoding()));
}
}
}
}
return ret;
}
OString JavaOptions::prepareHelp()
{
OString help("\nusing: ");
help += m_program + " [-options] file_1 ... file_n -Xfile_n+1 -Xfile_n+2\nOptions:\n";
help += " -O<path> = path describes the root directory for the generated output.\n";
help += " The output directory tree is generated under this directory.\n";
help += " -T<name> = name specifies a type or a list of types. The output for this\n";
help += " [t1;...] type and all dependent types are generated. If no '-T' option is \n";
help += " specified, then output for all types is generated.\n";
help += " Example: 'com.sun.star.uno.XInterface' is a valid type.\n";
help += " -B<name> = name specifies the base node. All types are searched under this\n";
help += " node. Default is the root '/' of the registry files.\n";
help += " -nD = no dependent types are generated.\n";
help += " -G = generate only target files which does not exists.\n";
help += " -Gc = generate only target files which content will be changed.\n";
help += " -X<file> = extra types which will not be taken into account for generation.\n";
help += prepareVersion();
return help;
}
OString JavaOptions::prepareVersion()
{
OString version("\nSun Microsystems (R) ");
version += m_program + " Version 2.0\n\n";
return version;
}
INTEGRATION: CWS changefileheader (1.11.38); FILE MERGED
2008/03/31 07:22:55 rt 1.11.38.1: #i87441# Change license header to LPGL v3.
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: javaoptions.cxx,v $
* $Revision: 1.12 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_codemaker.hxx"
#include <stdio.h>
#include <string.h>
#include "javaoptions.hxx"
#include "osl/process.h"
#include "osl/thread.h"
using namespace rtl;
sal_Bool JavaOptions::initOptions(int ac, char* av[], sal_Bool bCmdFile)
throw( IllegalArgument )
{
sal_Bool ret = sal_True;
sal_uInt16 i=0;
if (!bCmdFile)
{
bCmdFile = sal_True;
m_program = av[0];
if (ac < 2)
{
fprintf(stderr, "%s", prepareHelp().getStr());
ret = sal_False;
}
i = 1;
} else
{
i = 0;
}
char *s=NULL;
for( ; i < ac; i++)
{
if (av[i][0] == '-')
{
switch (av[i][1])
{
case 'O':
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-O', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
m_options["-O"] = OString(s);
break;
case 'B':
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-B', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
m_options["-B"] = OString(s);
break;
case 'n':
if (av[i][2] != 'D' || av[i][3] != '\0')
{
OString tmp("'-nD', please check");
tmp += " your input '" + OString(av[i]) + "'";
throw IllegalArgument(tmp);
}
m_options["-nD"] = OString("");
break;
case 'T':
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-T', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
if (m_options.count("-T") > 0)
{
OString tmp(m_options["-T"]);
tmp = tmp + ";" + s;
m_options["-T"] = tmp;
} else
{
m_options["-T"] = OString(s);
}
break;
case 'G':
if (av[i][2] == 'c')
{
if (av[i][3] != '\0')
{
OString tmp("'-Gc', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i]) + "'";
}
throw IllegalArgument(tmp);
}
m_options["-Gc"] = OString("");
break;
} else
if (av[i][2] != '\0')
{
OString tmp("'-G', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i]) + "'";
}
throw IllegalArgument(tmp);
}
m_options["-G"] = OString("");
break;
case 'X': // support for eXtra type rdbs
{
if (av[i][2] == '\0')
{
if (i < ac - 1 && av[i+1][0] != '-')
{
i++;
s = av[i];
} else
{
OString tmp("'-X', please check");
if (i <= ac - 1)
{
tmp += " your input '" + OString(av[i+1]) + "'";
}
throw IllegalArgument(tmp);
}
} else
{
s = av[i] + 2;
}
m_extra_input_files.push_back( s );
break;
}
default:
throw IllegalArgument("the option is unknown" + OString(av[i]));
}
} else
{
if (av[i][0] == '@')
{
FILE* cmdFile = fopen(av[i]+1, "r");
if( cmdFile == NULL )
{
fprintf(stderr, "%s", prepareHelp().getStr());
ret = sal_False;
} else
{
int rargc=0;
char* rargv[512];
char buffer[512];
while ( fscanf(cmdFile, "%s", buffer) != EOF )
{
rargv[rargc]= strdup(buffer);
rargc++;
}
fclose(cmdFile);
ret = initOptions(rargc, rargv, bCmdFile);
for (long j=0; j < rargc; j++)
{
free(rargv[j]);
}
}
} else
{
if (bCmdFile)
{
m_inputFiles.push_back(av[i]);
} else
{
OUString system_filepath;
if (osl_getCommandArg( i-1, &system_filepath.pData )
!= osl_Process_E_None)
{
OSL_ASSERT(false);
}
m_inputFiles.push_back(OUStringToOString(system_filepath, osl_getThreadTextEncoding()));
}
}
}
}
return ret;
}
OString JavaOptions::prepareHelp()
{
OString help("\nusing: ");
help += m_program + " [-options] file_1 ... file_n -Xfile_n+1 -Xfile_n+2\nOptions:\n";
help += " -O<path> = path describes the root directory for the generated output.\n";
help += " The output directory tree is generated under this directory.\n";
help += " -T<name> = name specifies a type or a list of types. The output for this\n";
help += " [t1;...] type and all dependent types are generated. If no '-T' option is \n";
help += " specified, then output for all types is generated.\n";
help += " Example: 'com.sun.star.uno.XInterface' is a valid type.\n";
help += " -B<name> = name specifies the base node. All types are searched under this\n";
help += " node. Default is the root '/' of the registry files.\n";
help += " -nD = no dependent types are generated.\n";
help += " -G = generate only target files which does not exists.\n";
help += " -Gc = generate only target files which content will be changed.\n";
help += " -X<file> = extra types which will not be taken into account for generation.\n";
help += prepareVersion();
return help;
}
OString JavaOptions::prepareVersion()
{
OString version("\nSun Microsystems (R) ");
version += m_program + " Version 2.0\n\n";
return version;
}
|
/*******************************************************************************
* E.S.O. - ACS project
*
* "@(#) $Id: acsdaemonStartContainer.cpp,v 1.14 2009/01/15 11:51:59 hsommer Exp $"
*
* who when what
* -------- ---------- ----------------------------------------------
* msekoran 2006/06/21 created
*/
/** @file acsdaemonStartContainer.cpp
* acsdaemonStartContainer is used to remotely start container via ACS Deamon.
* @htmlonly
* <br><hr>
* @endhtmlonly
*/
#include <acsutilPorts.h>
#include <logging.h>
#include <acsdaemonC.h>
#include <ACSErrTypeCommon.h>
#include <acsdaemonErrType.h>
#include <getopt.h>
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"type", required_argument, 0, 't'},
{"container", required_argument, 0, 'c'},
{"instance", required_argument, 0, 'i'},
{"host", required_argument, 0, 'H'},
{"daemon", required_argument, 0, 'd'},
{"additional", required_argument, 0, 'a'},
{"modifier", optional_argument, 0, 'm'},
{0, 0, 0, '\0'}};
void
usage(const char *argv)
{
ACE_OS::printf ("\n\tusage: %s {-h} -i INSTANCE -t TYPE -c CONTAINER [-d DAEMONREF] [-H HOST] [-m TYPE-MODIFIER] [-a more options]", argv);
ACE_OS::printf ("\t -h, --help show this help message\n");
ACE_OS::printf ("\t -t, --type container type: cpp, java, py\n");
ACE_OS::printf ("\t -c, --container container name\n");
ACE_OS::printf ("\t -i, --instance ACS instance to use\n");
ACE_OS::printf ("\t -H, --host Host where to start the container\n");
ACE_OS::printf ("\t -d, --daemon Daemon reference\n");
ACE_OS::printf ("\t -a, --additional passthrough options for startContaner. Put option between \"\"\n");
ACE_OS::printf ("\t -m, --modifier type modifier for the container (e.g. archiveContainer). More than one can be specified.\n");
}
int
main (int argc, char *argv[])
{
int c, instance = -1;
ACE_CString daemonRef;
ACE_CString hostName;
ACE_CString containerType;
ACE_CString containerName;
ACE_CString additional;
ACE_CString modstring;
ACS::stringSeq tmp_type_modifiers(100);
int modcount = 0;
//The modstring is used to collect all the provided modifiers so they can be logged.
modstring = "[ ";
for(;;)
{
int option_index = 0;
c = getopt_long (argc, argv, "ht:c:i:d:H:a:m:",
long_options, &option_index);
if (c==-1) break;
switch(c)
{
case 'h':
usage(argv[0]);
return 0;
case 'i':
instance = ACE_OS::atoi(optarg);
break;
case 'd':
daemonRef = optarg;
break;
case 'H':
hostName = optarg;
break;
case 't':
containerType = optarg;
break;
case 'c':
containerName = optarg;
break;
case 'a':
additional = optarg;
break;
case 'm':
tmp_type_modifiers[modcount] = CORBA::string_dup(optarg);
++modcount;
modstring = modstring + optarg + " ";
break;
}
}
modstring += "]";
//In order to get the length of the sequence correct, we have to transfer
//the values from the temporary sequence to the sequence we will send
//to the daemon.
ACS::stringSeq type_modifiers(modcount);
type_modifiers.length(modcount);
for (int i = 0; i < modcount; ++i) {
type_modifiers[i] = tmp_type_modifiers[i];
}
if (instance == -1)
{
ACE_OS::printf("Error: instance is a mandatory option try %s -h\n", argv[0]);
return -1;
}
if (containerType.length() == 0)
{
ACE_OS::printf("Error: container type is a mandatory option try %s -h\n", argv[0]);
return -1;
}
if (containerName.length() == 0)
{
ACE_OS::printf("Error: container name is a mandatory option try %s -h\n", argv[0]);
return -1;
}
LoggingProxy * logger = new LoggingProxy(0, 0, 31);
if (logger)
{
LoggingProxy::init(logger);
LoggingProxy::ProcessName(argv[0]);
LoggingProxy::ThreadName("main");
}
else
ACS_SHORT_LOG((LM_INFO, "Failed to initialize logging."));
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc,
argv,
"TAO"
);
// construct default one
if (daemonRef.length() == 0)
{
if(hostName.length() == 0)
{
hostName = ACSPorts::getIP();
}
daemonRef = "corbaloc::";
daemonRef = daemonRef + hostName + ":" + ACSPorts::getContainerDaemonPort().c_str() + "/" + ::acsdaemon::containerDaemonServiceName;
ACS_SHORT_LOG((LM_INFO, "Using local Container Daemon reference: '%s'", daemonRef.c_str()));
}
else
{
ACS_SHORT_LOG((LM_INFO, "Container Daemon reference obtained via command line: '%s'", daemonRef.c_str()));
}
CORBA::Object_var obj = orb->string_to_object(daemonRef.c_str());
if (CORBA::is_nil(obj.in()))
{
ACS_SHORT_LOG((LM_INFO, "Failed to resolve reference '%s'.", daemonRef.c_str()));
return -1;
}
acsdaemon::ContainerDaemon_var daemon = acsdaemon::ContainerDaemon::_narrow(obj.in());
if (CORBA::is_nil(daemon.in()))
{
ACS_SHORT_LOG((LM_INFO, "Failed to narrow reference '%s'.", daemonRef.c_str()));
return -1;
}
// @TODO: implement support for
ACS_SHORT_LOG((LM_INFO, "Calling start_container(%s, %s, %d, %s, %s).", containerType.c_str(), containerName.c_str(), instance, modstring.c_str(), additional.c_str()));
daemon->start_container(containerType.c_str(), containerName.c_str(), instance, type_modifiers, additional.c_str());
ACS_SHORT_LOG((LM_INFO, "Container start message issued."));
}
catch (ACSErrTypeCommon::BadParameterEx &ex)
{
ACSErrTypeCommon::BadParameterExImpl exImpl(ex);
exImpl.log();
return -1;
}
catch (acsdaemonErrType::FailedToStartContainerEx &ex)
{
acsdaemonErrType::FailedToStartContainerExImpl exImpl(ex);
exImpl.log();
return -1;
}
catch( CORBA::Exception &ex )
{
ACS_SHORT_LOG((LM_INFO, "Failed."));
ACE_PRINT_EXCEPTION (ex, ACE_TEXT ("Caught unexpected exception:"));
return -1;
}
return 0;
}
set length of sequence tmp_type_modifiers to 100 otherwise access to the fileds of sequence will fail with ACE+TAO x.7.8
git-svn-id: afcf11d89342f630bd950d18a70234a9e277d909@132676 523d945c-050c-4681-91ec-863ad3bb968a
/*******************************************************************************
* E.S.O. - ACS project
*
* "@(#) $Id: acsdaemonStartContainer.cpp,v 1.15 2010/05/31 09:24:07 bjeram Exp $"
*
* who when what
* -------- ---------- ----------------------------------------------
* msekoran 2006/06/21 created
*/
/** @file acsdaemonStartContainer.cpp
* acsdaemonStartContainer is used to remotely start container via ACS Deamon.
* @htmlonly
* <br><hr>
* @endhtmlonly
*/
#include <acsutilPorts.h>
#include <logging.h>
#include <acsdaemonC.h>
#include <ACSErrTypeCommon.h>
#include <acsdaemonErrType.h>
#include <getopt.h>
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"type", required_argument, 0, 't'},
{"container", required_argument, 0, 'c'},
{"instance", required_argument, 0, 'i'},
{"host", required_argument, 0, 'H'},
{"daemon", required_argument, 0, 'd'},
{"additional", required_argument, 0, 'a'},
{"modifier", optional_argument, 0, 'm'},
{0, 0, 0, '\0'}};
void
usage(const char *argv)
{
ACE_OS::printf ("\n\tusage: %s {-h} -i INSTANCE -t TYPE -c CONTAINER [-d DAEMONREF] [-H HOST] [-m TYPE-MODIFIER] [-a more options]", argv);
ACE_OS::printf ("\t -h, --help show this help message\n");
ACE_OS::printf ("\t -t, --type container type: cpp, java, py\n");
ACE_OS::printf ("\t -c, --container container name\n");
ACE_OS::printf ("\t -i, --instance ACS instance to use\n");
ACE_OS::printf ("\t -H, --host Host where to start the container\n");
ACE_OS::printf ("\t -d, --daemon Daemon reference\n");
ACE_OS::printf ("\t -a, --additional passthrough options for startContaner. Put option between \"\"\n");
ACE_OS::printf ("\t -m, --modifier type modifier for the container (e.g. archiveContainer). More than one can be specified.\n");
}
int
main (int argc, char *argv[])
{
int c, instance = -1;
ACE_CString daemonRef;
ACE_CString hostName;
ACE_CString containerType;
ACE_CString containerName;
ACE_CString additional;
ACE_CString modstring;
ACS::stringSeq tmp_type_modifiers(100);
tmp_type_modifiers.length(100);
int modcount = 0;
//The modstring is used to collect all the provided modifiers so they can be logged.
modstring = "[ ";
for(;;)
{
int option_index = 0;
c = getopt_long (argc, argv, "ht:c:i:d:H:a:m:",
long_options, &option_index);
if (c==-1) break;
switch(c)
{
case 'h':
usage(argv[0]);
return 0;
case 'i':
instance = ACE_OS::atoi(optarg);
break;
case 'd':
daemonRef = optarg;
break;
case 'H':
hostName = optarg;
break;
case 't':
containerType = optarg;
break;
case 'c':
containerName = optarg;
break;
case 'a':
additional = optarg;
break;
case 'm':
tmp_type_modifiers[modcount] = CORBA::string_dup(optarg);
++modcount;
modstring = modstring + optarg + " ";
break;
}
}
modstring += "]";
//In order to get the length of the sequence correct, we have to transfer
//the values from the temporary sequence to the sequence we will send
//to the daemon.
ACS::stringSeq type_modifiers(modcount);
type_modifiers.length(modcount);
for (int i = 0; i < modcount; ++i) {
type_modifiers[i] = tmp_type_modifiers[i];
}
if (instance == -1)
{
ACE_OS::printf("Error: instance is a mandatory option try %s -h\n", argv[0]);
return -1;
}
if (containerType.length() == 0)
{
ACE_OS::printf("Error: container type is a mandatory option try %s -h\n", argv[0]);
return -1;
}
if (containerName.length() == 0)
{
ACE_OS::printf("Error: container name is a mandatory option try %s -h\n", argv[0]);
return -1;
}
LoggingProxy * logger = new LoggingProxy(0, 0, 31);
if (logger)
{
LoggingProxy::init(logger);
LoggingProxy::ProcessName(argv[0]);
LoggingProxy::ThreadName("main");
}
else
ACS_SHORT_LOG((LM_INFO, "Failed to initialize logging."));
try
{
// Initialize the ORB.
CORBA::ORB_var orb = CORBA::ORB_init (argc,
argv,
"TAO"
);
// construct default one
if (daemonRef.length() == 0)
{
if(hostName.length() == 0)
{
hostName = ACSPorts::getIP();
}
daemonRef = "corbaloc::";
daemonRef = daemonRef + hostName + ":" + ACSPorts::getContainerDaemonPort().c_str() + "/" + ::acsdaemon::containerDaemonServiceName;
ACS_SHORT_LOG((LM_INFO, "Using local Container Daemon reference: '%s'", daemonRef.c_str()));
}
else
{
ACS_SHORT_LOG((LM_INFO, "Container Daemon reference obtained via command line: '%s'", daemonRef.c_str()));
}
CORBA::Object_var obj = orb->string_to_object(daemonRef.c_str());
if (CORBA::is_nil(obj.in()))
{
ACS_SHORT_LOG((LM_INFO, "Failed to resolve reference '%s'.", daemonRef.c_str()));
return -1;
}
acsdaemon::ContainerDaemon_var daemon = acsdaemon::ContainerDaemon::_narrow(obj.in());
if (CORBA::is_nil(daemon.in()))
{
ACS_SHORT_LOG((LM_INFO, "Failed to narrow reference '%s'.", daemonRef.c_str()));
return -1;
}
// @TODO: implement support for
ACS_SHORT_LOG((LM_INFO, "Calling start_container(%s, %s, %d, %s, %s).", containerType.c_str(), containerName.c_str(), instance, modstring.c_str(), additional.c_str()));
daemon->start_container(containerType.c_str(), containerName.c_str(), instance, type_modifiers, additional.c_str());
ACS_SHORT_LOG((LM_INFO, "Container start message issued."));
}
catch (ACSErrTypeCommon::BadParameterEx &ex)
{
ACSErrTypeCommon::BadParameterExImpl exImpl(ex);
exImpl.log();
return -1;
}
catch (acsdaemonErrType::FailedToStartContainerEx &ex)
{
acsdaemonErrType::FailedToStartContainerExImpl exImpl(ex);
exImpl.log();
return -1;
}
catch( CORBA::Exception &ex )
{
ACS_SHORT_LOG((LM_INFO, "Failed."));
ACE_PRINT_EXCEPTION (ex, ACE_TEXT ("Caught unexpected exception:"));
return -1;
}
return 0;
}
|
#include "oclint/rule/LongParameterListRule.h"
#include "oclint/RuleSet.h"
#include "oclint/RuleConfiguration.h"
#include "oclint/ViolationSet.h"
#include "oclint/Violation.h"
#include "oclint/helper/CursorHelper.h"
#include "oclint/helper/DeclHelper.h"
#include <clang/AST/Decl.h>
#include <clang/AST/DeclObjC.h>
#include <clang/AST/DeclCXX.h>
#define DEFAULT_MAX_ALLOWED_PARAMS 3
RuleSet LongParameterListRule::rules(new LongParameterListRule());
int LongParameterListRule::maxAllowedNumberOfParameters() {
string key = "NUMBER_OF_PARAMETERS";
return RuleConfiguration::hasKey(key) ? atoi(RuleConfiguration::valueForKey(key).c_str()) : DEFAULT_MAX_ALLOWED_PARAMS;
}
int LongParameterListRule::numberOfParameters(Decl *decl) {
if (decl) {
ObjCMethodDecl *objcMethodDecl = dyn_cast<ObjCMethodDecl>(decl);
if (objcMethodDecl && !DeclHelper::isObjCMethodDeclaredInSuperClass(objcMethodDecl) && !DeclHelper::isObjCMethodDeclaredInProtocol(objcMethodDecl)) {
return objcMethodDecl->getNumSelectorArgs();
}
FunctionDecl *cppMethodDecl = dyn_cast<FunctionDecl>(decl);
if (cppMethodDecl) {
return cppMethodDecl->getNumParams();
}
}
return 0;
}
void LongParameterListRule::apply(CXCursor& node, CXCursor& parentNode, ViolationSet& violationSet) {
Decl *decl = CursorHelper::getDecl(node);
if (numberOfParameters(decl) > maxAllowedNumberOfParameters()) {
Violation violation(node, this);
violationSet.addViolation(violation);
}
}
const string LongParameterListRule::name() const {
return "long parameter list";
}
Update method call with new API to get correct number of arguments.
#include "oclint/rule/LongParameterListRule.h"
#include "oclint/RuleSet.h"
#include "oclint/RuleConfiguration.h"
#include "oclint/ViolationSet.h"
#include "oclint/Violation.h"
#include "oclint/helper/CursorHelper.h"
#include "oclint/helper/DeclHelper.h"
#include <clang/AST/Decl.h>
#include <clang/AST/DeclObjC.h>
#include <clang/AST/DeclCXX.h>
#define DEFAULT_MAX_ALLOWED_PARAMS 3
RuleSet LongParameterListRule::rules(new LongParameterListRule());
int LongParameterListRule::maxAllowedNumberOfParameters() {
string key = "NUMBER_OF_PARAMETERS";
return RuleConfiguration::hasKey(key) ? atoi(RuleConfiguration::valueForKey(key).c_str()) : DEFAULT_MAX_ALLOWED_PARAMS;
}
int LongParameterListRule::numberOfParameters(Decl *decl) {
if (decl) {
ObjCMethodDecl *objcMethodDecl = dyn_cast<ObjCMethodDecl>(decl);
if (objcMethodDecl && !DeclHelper::isObjCMethodDeclaredInSuperClass(objcMethodDecl) && !DeclHelper::isObjCMethodDeclaredInProtocol(objcMethodDecl)) {
return objcMethodDecl->getNumSelectorLocs();
}
FunctionDecl *cppMethodDecl = dyn_cast<FunctionDecl>(decl);
if (cppMethodDecl) {
return cppMethodDecl->getNumParams();
}
}
return 0;
}
void LongParameterListRule::apply(CXCursor& node, CXCursor& parentNode, ViolationSet& violationSet) {
Decl *decl = CursorHelper::getDecl(node);
if (numberOfParameters(decl) > maxAllowedNumberOfParameters()) {
Violation violation(node, this);
violationSet.addViolation(violation);
}
}
const string LongParameterListRule::name() const {
return "long parameter list";
}
|
/* SectionStyle: Stores (and writes) section-based information (e.g.: a column
* break needs a new section) that is needed at the head of an OO document and
* is referenced throughout the entire document
*
* Copyright (C) 2002-2003 William Lachance (william.lachance@sympatico.ca)
* Copyright (c) 2004 Fridrich Strba (fridrich.strba@bluewin.ch)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* For further information visit http://libwpd.sourceforge.net
*
*/
/* "This product is not manufactured, approved, or supported by
* Corel Corporation or Corel Corporation Limited."
*/
#include "FilterInternal.hxx"
#include "SectionStyle.hxx"
#include "DocumentElement.hxx"
#include <math.h>
#ifdef _MSC_VER
double rint(double x);
#endif /* _WIN32 */
const float fDefaultSideMargin = 1.0f; // inches
const float fDefaultPageWidth = 8.5f; // inches (OOo required default: we will handle this later)
const float fDefaultPageHeight = 11.0f; // inches
SectionStyle::SectionStyle(const WPXPropertyList &xPropList,
const WPXPropertyListVector &xColumns,
const char *psName) :
Style(psName),
mPropList(xPropList),
mColumns(xColumns)
{
}
void SectionStyle::write(DocumentHandler &xHandler) const
{
TagOpenElement styleOpen("style:style");
styleOpen.addAttribute("style:name", getName());
styleOpen.addAttribute("style:family", "section");
styleOpen.write(xHandler);
// if the number of columns is <= 1, we will never come here. This is only an additional check
if (mColumns.count() > 1)
{
// style properties
xHandler.startElement("style:properties", mPropList);
// column properties
WPXPropertyList columnProps;
columnProps.insert("fo:column-count", (int)mColumns.count());
xHandler.startElement("style:columns", columnProps);
WPXPropertyListVector::Iter i(mColumns);
for (i.rewind(); i.next();)
{
xHandler.startElement("style:column", i());
xHandler.endElement("style:column");
}
xHandler.endElement("style:columns");
xHandler.endElement("style:properties");
}
xHandler.endElement("style:style");
}
INTEGRATION: CWS fs08 (1.2.38); FILE MERGED
2007/01/04 11:44:20 fridrich_strba 1.2.38.2: some improvements and bug-fixes from cws wpsimport01
2006/12/19 10:09:06 fridrich_strba 1.2.38.1: removing memory leaks and warnings with GNU/Linux gcc 3.4.5
/* SectionStyle: Stores (and writes) section-based information (e.g.: a column
* break needs a new section) that is needed at the head of an OO document and
* is referenced throughout the entire document
*
* Copyright (C) 2002-2003 William Lachance (william.lachance@sympatico.ca)
* Copyright (c) 2004 Fridrich Strba (fridrich.strba@bluewin.ch)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* For further information visit http://libwpd.sourceforge.net
*
*/
/* "This product is not manufactured, approved, or supported by
* Corel Corporation or Corel Corporation Limited."
*/
#include "FilterInternal.hxx"
#include "SectionStyle.hxx"
#include "DocumentElement.hxx"
#include <math.h>
#ifdef _MSC_VER
double rint(double x);
#endif /* _WIN32 */
SectionStyle::SectionStyle(const WPXPropertyList &xPropList,
const WPXPropertyListVector &xColumns,
const char *psName) :
Style(psName),
mPropList(xPropList),
mColumns(xColumns)
{
}
void SectionStyle::write(DocumentHandler *pHandler) const
{
TagOpenElement styleOpen("style:style");
styleOpen.addAttribute("style:name", getName());
styleOpen.addAttribute("style:family", "section");
styleOpen.write(pHandler);
// if the number of columns is <= 1, we will never come here. This is only an additional check
// style properties
pHandler->startElement("style:properties", mPropList);
// column properties
WPXPropertyList columnProps;
if (mColumns.count() > 1)
{
columnProps.insert("fo:column-count", (int)mColumns.count());
pHandler->startElement("style:columns", columnProps);
WPXPropertyListVector::Iter i(mColumns);
for (i.rewind(); i.next();)
{
pHandler->startElement("style:column", i());
pHandler->endElement("style:column");
}
}
else
{
columnProps.insert("fo:column-count", 0);
columnProps.insert("fo:column-gap", 0.0f);
pHandler->startElement("style:columns", columnProps);
}
pHandler->endElement("style:columns");
pHandler->endElement("style:properties");
pHandler->endElement("style:style");
}
|
/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
// Wrappers
#include "otbWrapperApplication.h"
#include "otbWrapperApplicationFactory.h"
#include "otbWrapperApplicationRegistry.h"
#include "otbWrapperAddProcessToWatchEvent.h"
#include "otbWrapperProxyParameter.h"
#include "otbWrapperParameterKey.h"
#include "itkStdStreamLogOutput.h"
namespace otb
{
namespace Wrapper
{
class CompositeTrain : public Application
{
public:
/** Standard class typedefs. */
typedef CompositeTrain Self;
typedef Application Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Standard macro */
itkNewMacro(Self);
itkTypeMacro(CompositeTrain, otb::Application);
/** Filters typedef */
typedef itk::MemberCommand< Self > AddProcessCommandType;
typedef struct
{
Application::Pointer App;
std::string Desc;
} InternalApplication;
typedef std::map<std::string, InternalApplication> InternalAppContainer;
protected:
void LinkWatchers(itk::Object * itkNotUsed(caller), const itk::EventObject & event)
{
if (typeid(AddProcessToWatchEvent) == typeid( event ))
{
this->InvokeEvent(event);
}
}
CompositeTrain()
{
m_LogOutput = itk::StdStreamLogOutput::New();
m_LogOutput->SetStream(m_Oss);
m_AddProcessCommand = AddProcessCommandType::New();
m_AddProcessCommand->SetCallbackFunction(this, &CompositeTrain::LinkWatchers);
}
private:
InternalAppContainer m_AppContainer;
/**
* Method to instanciate and register a new internal application
* \param appType Type of the application to instanciate
* \param key Identifier associated to the created application
* \param desc Description of the internal application
*/
bool AddApplication(std::string appType, std::string key, std::string desc)
{
if (m_AppContainer.count(key))
{
otbAppLogWARNING("The requested identifier for internal application is already used ("<<key<<")");
return false;
}
InternalAppContainer container;
container.App = ApplicationRegistry::CreateApplication(appType);
container.Desc = desc;
// Setup logger
container.App->GetLogger()->AddLogOutput(m_LogOutput);
container.App->GetLogger()->SetTimeStampFormat(itk::LoggerBase::HUMANREADABLE);
container.App->AddObserver(AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer());
m_AppContainer[key] = container;
return true;
}
bool Connect(Application *app1, std::string key1, Application *app2, std::string key2)
{
Parameter* rawParam1 = app1->GetParameterByKey(key1, false);
if (dynamic_cast<ProxyParameter*>(rawParam1))
{
otbAppLogWARNING("First parameter is already connected !");
return false;
}
ProxyParameter::Pointer proxyParam = ProxyParameter::New();
ProxyParameter::ProxyTargetType target;
target.first = app2->GetParameterList();
target.second = key2;
proxyParam->SetTarget(target);
proxyParam->SetName(rawParam1->GetName());
proxyParam->SetDescription(rawParam1->GetDescription());
return app1->GetParameterList()->SetParameter(proxyParam.GetPointer(),key1);
}
bool Connect(std::string key1, std::string key2)
{
size_t pos1 = key1.find('.');
size_t pos2 = key2.find('.');
Application *app1 = this;
Application *app2 = this;
std::string key1Check(key1);
std::string key2Check(key2);
if (pos1 != std::string::npos && m_AppContainer.count(key1.substr(0,pos1)))
{
app1 = m_AppContainer[key1.substr(0,pos1)].App;
key1Check = key1.substr(pos1+1);
}
if (pos2 != std::string::npos && m_AppContainer.count(key2.substr(0,pos2)))
{
app2 = m_AppContainer[key2.substr(0,pos2)].App;
key2Check = key2.substr(pos2+1);
}
return this->Connect(app1, key1Check, app2, key2Check);
}
void DoExecuteInternal(std::string key)
{
otbAppLogINFO(<< m_AppContainer[key].Desc <<"...");
m_AppContainer[key].App->Execute();
otbAppLogINFO(<< "\n" << m_Oss.str());
m_Oss.str(std::string(""));
}
void DoInit() ITK_OVERRIDE
{
SetName("CompositeTrain");
SetDescription("Composite application for classifier training.");
SetDocName("Composite Train");
SetDocLongDescription(" TODO");
SetDocLimitations(" TODO");
SetDocAuthors("OTB-Team");
SetDocSeeAlso(" ");
AddDocTag(Tags::Learning);
this->AddApplication("PolygonClassStatistics", "polystat","Polygon analysis");
this->AddApplication("SampleSelection", "select", "Sample selection");
// share parameters with PolygonClassStatistics
this->GetParameterList()->AddParameter(m_PolygonAnalysis->GetParameterByKey("in"));
this->GetParameterList()->AddParameter(m_PolygonAnalysis->GetParameterByKey("vec"));
//this->GetParameterList()->AddParameter(m_PolygonAnalysis->GetParameterByKey("field"));
this->GetParameterList()->AddParameter(m_PolygonAnalysis->GetParameterByKey("layer"));
AddParameter(ParameterType_Group, "sample", "Training and validation samples parameters");
SetParameterDescription("sample",
"This group of parameters allows you to set training and validation sample lists parameters.");
this->Connect("sample.vfn", "polystat.field");
// share parameters with SampleSelection
this->GetParameterList()->AddParameter(m_SampleSelection->GetParameterByKey("out"));
this->GetParameterList()->AddParameter(m_SampleSelection->GetParameterByKey("strategy"));
m_PolygonAnalysis->GetLogger()->AddLogOutput(m_LogOutput);
m_PolygonAnalysis->GetLogger()->SetTimeStampFormat(itk::LoggerBase::HUMANREADABLE);
m_SampleSelection->GetLogger()->AddLogOutput(m_LogOutput);
m_SampleSelection->GetLogger()->SetTimeStampFormat(itk::LoggerBase::HUMANREADABLE);
// Progress
// Add the callback to be added when a AddProcessToWatch event is invoked
m_PolygonAnalysis->AddObserver(AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer());
m_SampleSelection->AddObserver(AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer());
// Doc example parameter settings
SetDocExampleParameterValue("io.in", "clLabeledImageQB123_1.tif");
SetDocExampleParameterValue("io.out", "clLabeledImageQB123_1_CMR_r2_nodl_10_undl_7.tif");
SetDocExampleParameterValue("ip.radius", "2");
SetDocExampleParameterValue("ip.suvbool", "true");
SetDocExampleParameterValue("ip.nodatalabel", "10");
SetDocExampleParameterValue("ip.undecidedlabel", "7");
}
void DoUpdateParameters() ITK_OVERRIDE
{
// copy common values
// "in" -> "SampleSelection.in"
// "vec" -> "SampleSelection.in"
// "field" -> "SampleSelection.in"
// "layer" -> "SampleSelection.in"
m_SampleSelection->SetParameterString("in",this->GetParameterString("in"));
m_SampleSelection->SetParameterString("vec",this->GetParameterString("vec"));
m_SampleSelection->SetParameterString("field",this->GetParameterString("sample.vfn"));
m_SampleSelection->SetParameterInt("layer",this->GetParameterInt("layer"));
if (HasValue("out"))
{
// TODO : get dirname, and prepare name of temporary output
m_PolygonAnalysis->SetParameterString("out", std::string("foo.xml"));
m_SampleSelection->SetParameterString("instats", std::string("foo.xml"));
}
// DoUpdateParameters on sub-application
m_PolygonAnalysis->UpdateParameters();
m_SampleSelection->UpdateParameters();
}
void DoExecute() ITK_OVERRIDE
{
this->DoExecuteInternal("polystat");
this->DoExecuteInternal("select");
}// END DoExecute()
Application::Pointer m_PolygonAnalysis;
Application::Pointer m_SampleSelection;
itk::StdStreamLogOutput::Pointer m_LogOutput;
std::ostringstream m_Oss;
AddProcessCommandType::Pointer m_AddProcessCommand;
}; // END class CompositeTrain
}// END namespace wrapper
}// END namespace otb
OTB_APPLICATION_EXPORT(otb::Wrapper::CompositeTrain)
ENH: work on common CompositeApp functions
/*=========================================================================
Program: ORFEO Toolbox
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
See OTBCopyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
// Wrappers
#include "otbWrapperApplication.h"
#include "otbWrapperApplicationFactory.h"
#include "otbWrapperApplicationRegistry.h"
#include "otbWrapperAddProcessToWatchEvent.h"
#include "otbWrapperProxyParameter.h"
#include "otbWrapperParameterKey.h"
#include "itkStdStreamLogOutput.h"
namespace otb
{
namespace Wrapper
{
class CompositeTrain : public Application
{
public:
/** Standard class typedefs. */
typedef CompositeTrain Self;
typedef Application Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Standard macro */
itkNewMacro(Self);
itkTypeMacro(CompositeTrain, otb::Application);
/** Filters typedef */
typedef itk::MemberCommand< Self > AddProcessCommandType;
typedef struct
{
Application::Pointer App;
std::string Desc;
} InternalApplication;
typedef std::map<std::string, InternalApplication> InternalAppContainer;
protected:
void LinkWatchers(itk::Object * itkNotUsed(caller), const itk::EventObject & event)
{
if (typeid(AddProcessToWatchEvent) == typeid( event ))
{
this->InvokeEvent(event);
}
}
CompositeTrain()
{
m_LogOutput = itk::StdStreamLogOutput::New();
m_LogOutput->SetStream(m_Oss);
m_AddProcessCommand = AddProcessCommandType::New();
m_AddProcessCommand->SetCallbackFunction(this, &CompositeTrain::LinkWatchers);
}
private:
/**
* Method to instanciate and register a new internal application
* \param appType Type of the application to instanciate
* \param key Identifier associated to the created application
* \param desc Description of the internal application
*/
bool AddApplication(std::string appType, std::string key, std::string desc)
{
if (m_AppContainer.count(key))
{
otbAppLogWARNING("The requested identifier for internal application is already used ("<<key<<")");
return false;
}
InternalApplication container;
container.App = ApplicationRegistry::CreateApplication(appType);
container.Desc = desc;
// Setup logger
container.App->GetLogger()->AddLogOutput(m_LogOutput);
container.App->GetLogger()->SetTimeStampFormat(itk::LoggerBase::HUMANREADABLE);
container.App->AddObserver(AddProcessToWatchEvent(), m_AddProcessCommand.GetPointer());
m_AppContainer[key] = container;
return true;
}
/**
* Connect two existing parameters together. The first parameter will point to
* the second parameter.
*/
bool Connect(std::string fromKey, std::string toKey)
{
std::string key1(fromKey);
std::string key2(toKey);
Application *app1 = DecodeKey(key1);
Application *app2 = DecodeKey(key2);
Parameter* rawParam1 = app1->GetParameterByKey(key1, false);
if (dynamic_cast<ProxyParameter*>(rawParam1))
{
otbAppLogWARNING("Parameter is already connected ! Override current connection");
}
ProxyParameter::Pointer proxyParam = ProxyParameter::New();
ProxyParameter::ProxyTargetType target;
target.first = app2->GetParameterList();
target.second = key2;
proxyParam->SetTarget(target);
proxyParam->SetName(rawParam1->GetName());
proxyParam->SetDescription(rawParam1->GetDescription());
return app1->GetParameterList()->SetParameter(proxyParam.GetPointer(),key1);
}
/**
* Share a parameter between the composite application and an internal application
* The local parameter is created as a proxy to the internal parameter.
* \param localKey New parameter key in the composite application
* \param internalKey Key to the internal parameter to expose
* \param name Name for the local parameter, if empty the target's name is used
* \param desc Description for the local parameter, if empty the target's description is used
*/
bool ShareParameter(std::string localKey,
std::string internalKey,
std::string name = std::string(),
std::string desc = std::string())
{
std::string internalKeyCheck(internalKey);
Application *app = DecodeKey(internalKeyCheck);
Parameter* rawTarget = app->GetParameterByKey(internalKeyCheck, false);
ProxyParameter::Pointer proxyParam = ProxyParameter::New();
ProxyParameter::ProxyTargetType target;
target.first = app->GetParameterList();
target.second = internalKeyCheck;
proxyParam->SetTarget(target);
proxyParam->SetName( name.empty() ? rawTarget->GetName() : name);
proxyParam->SetDescription(desc.empty() ? rawTarget->GetDescription() : desc);
return this->GetParameterList()->SetParameter(proxyParam.GetPointer(),localKey);
}
/**
* Decode a key to extract potential prefix for internal applications
* If a valid prefix (corresponding to an internal app) is found:
* - prefix is removed from the input key which is altered.
* - the function returns a pointer to the internal application
* If no valid prefix is found, the input key is not modified, and the
* function returns 'this'.
*/
Application* DecodeKey(std::string &key)
{
Application *ret = this;
size_t pos = key.find('.');
if (pos != std::string::npos && m_AppContainer.count(key.substr(0,pos)))
{
ret = m_AppContainer[key.substr(0,pos)].App;
key = key.substr(pos+1);
}
return ret;
}
void ExecuteInternal(std::string key)
{
otbAppLogINFO(<< m_AppContainer[key].Desc <<"...");
m_AppContainer[key].App->Execute();
otbAppLogINFO(<< "\n" << m_Oss.str());
m_Oss.str(std::string(""));
}
void UpdateParametersInternal(std::string key)
{
m_AppContainer[key].App->UpdateParameters();
}
void DoInit() ITK_OVERRIDE
{
SetName("CompositeTrain");
SetDescription("Composite application for classifier training.");
SetDocName("Composite Train");
SetDocLongDescription(" TODO");
SetDocLimitations(" TODO");
SetDocAuthors("OTB-Team");
SetDocSeeAlso(" ");
AddDocTag(Tags::Learning);
AddParameter(ParameterType_Group, "sample", "Training and validation samples parameters");
SetParameterDescription("sample", "This group of parameters allows you to "
"set training and validation sample lists parameters.");
AddApplication("PolygonClassStatistics", "polystat","Polygon analysis");
AddApplication("SampleSelection", "select", "Sample selection");
// share parameters with PolygonClassStatistics
ShareParameter("in","polystat.in");
ShareParameter("vec","polystat.vec");
ShareParameter("layer","polystat.layer");
ShareParameter("sample.vfn", "polystat.field");
// share parameters with SampleSelection
ShareParameter("out", "select.out");
ShareParameter("strat", "select.strategy");
// synchronize some parameters together:
Connect("select.in", "polystat.in");
Connect("select.vec", "polystat.vec");
Connect("select.field", "polystat.field");
Connect("select.layer", "polystat.layer");
Connect("select.instats", "polystat.out");
// Doc example parameter settings
SetDocExampleParameterValue("io.in", "clLabeledImageQB123_1.tif");
SetDocExampleParameterValue("io.out", "clLabeledImageQB123_1_CMR_r2_nodl_10_undl_7.tif");
SetDocExampleParameterValue("ip.radius", "2");
SetDocExampleParameterValue("ip.suvbool", "true");
SetDocExampleParameterValue("ip.nodatalabel", "10");
SetDocExampleParameterValue("ip.undecidedlabel", "7");
}
void DoUpdateParameters() ITK_OVERRIDE
{
if (HasValue("out"))
{
// TODO : get dirname, and prepare name of temporary output
m_AppContainer["polystat"].App->SetParameterString("out", std::string("foo.xml"));
}
// DoUpdateParameters on sub-application
UpdateParametersInternal("polystat");
UpdateParametersInternal("select");
}
void DoExecute() ITK_OVERRIDE
{
this->ExecuteInternal("polystat");
this->ExecuteInternal("select");
}// END DoExecute()
InternalAppContainer m_AppContainer;
itk::StdStreamLogOutput::Pointer m_LogOutput;
std::ostringstream m_Oss;
AddProcessCommandType::Pointer m_AddProcessCommand;
}; // END class CompositeTrain
}// END namespace wrapper
}// END namespace otb
OTB_APPLICATION_EXPORT(otb::Wrapper::CompositeTrain)
|
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef itkClampImageFilter_hxx
#define itkClampImageFilter_hxx
#include "itkClampImageFilter.h"
#include "itkProgressReporter.h"
#include "itkMath.h"
namespace itk
{
namespace Functor
{
template< typename TInput, typename TOutput >
Clamp< TInput, TOutput >
::Clamp() :
m_LowerBound(NumericTraits< OutputType >::NonpositiveMin()),
m_UpperBound(NumericTraits< OutputType >::max())
{}
template< typename TInput, typename TOutput >
Clamp< TInput, TOutput >
::~Clamp() {}
template< typename TInput, typename TOutput >
typename Clamp< TInput, TOutput >::OutputType
Clamp< TInput, TOutput >
::GetLowerBound() const
{ return m_LowerBound; }
template< typename TInput, typename TOutput >
typename Clamp< TInput, TOutput >::OutputType
Clamp< TInput, TOutput >
::GetUpperBound() const
{ return m_UpperBound; }
template< typename TInput, typename TOutput >
void
Clamp< TInput, TOutput >
::SetBounds( const OutputType lowerBound, const OutputType upperBound)
{
if(lowerBound > upperBound)
{
itkGenericExceptionMacro("invalid bounds: [" << lowerBound << "; " << upperBound << "]");
}
m_LowerBound = lowerBound;
m_UpperBound = upperBound;
}
template< typename TInput, typename TOutput >
bool
Clamp< TInput, TOutput >
::operator!=( const Self & other ) const
{
return m_UpperBound != other.m_UpperBound
|| m_LowerBound != other.m_LowerBound;
}
template< typename TInput, typename TOutput >
bool
Clamp< TInput, TOutput >
::operator==( const Self & other ) const
{
return !(*this != other);
}
} // end namespace Functor
template <typename TInputImage, typename TOutputImage>
ClampImageFilter< TInputImage, TOutputImage >
::ClampImageFilter() {}
template <typename TInputImage, typename TOutputImage>
typename ClampImageFilter< TInputImage, TOutputImage >::OutputPixelType
ClampImageFilter< TInputImage, TOutputImage >
::GetLowerBound() const
{
return this->GetFunctor().GetLowerBound();
}
template <typename TInputImage, typename TOutputImage>
typename ClampImageFilter< TInputImage, TOutputImage >::OutputPixelType
ClampImageFilter< TInputImage, TOutputImage >
::GetUpperBound() const
{
return this->GetFunctor().GetUpperBound();
}
template <typename TInputImage, typename TOutputImage>
void
ClampImageFilter< TInputImage, TOutputImage >
::SetBounds(const OutputPixelType lowerBound, const OutputPixelType upperBound)
{
if ( Math::ExactlyEquals(lowerBound, this->GetFunctor().GetLowerBound()) && Math::ExactlyEquals(upperBound, this->GetFunctor().GetUpperBound()))
{
return;
}
this->GetFunctor().SetBounds(lowerBound, upperBound);
this->Modified();
}
template <typename TInputImage, typename TOutputImage>
void
ClampImageFilter< TInputImage, TOutputImage >
::GenerateData()
{
if( this->GetInPlace() && this->CanRunInPlace()
&& this->GetLowerBound() <= NumericTraits< OutputPixelType >::NonpositiveMin()
&& this->GetUpperBound() >= NumericTraits< OutputPixelType >::max() )
{
// If the filter is asked to run in-place, is able to run in-place,
// and the specified bounds are equal to the output-type limits,
// then there is nothing to do. To avoid iterating over all the pixels for
// nothing, graft the input to the output, generate a fake progress and exit.
this->AllocateOutputs();
ProgressReporter progress(this, 0, 1);
return;
}
Superclass::GenerateData();
}
template <typename TInputImage, typename TOutputImage>
void
ClampImageFilter< TInputImage, TOutputImage >
::PrintSelf(std::ostream & os, Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "Lower bound: " << this->GetLowerBound() << std::endl;
os << indent << "Upper bound: " << this->GetUpperBound() << std::endl;
}
}
#endif
BUG: Fix ivar type casting in PrintSelf.
Add type casting to the appropriate types for printing ivars.
Change-Id: I578ceaae44fa6af79a145ef1ea0aab742625e33e
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef itkClampImageFilter_hxx
#define itkClampImageFilter_hxx
#include "itkClampImageFilter.h"
#include "itkProgressReporter.h"
#include "itkMath.h"
namespace itk
{
namespace Functor
{
template< typename TInput, typename TOutput >
Clamp< TInput, TOutput >
::Clamp() :
m_LowerBound(NumericTraits< OutputType >::NonpositiveMin()),
m_UpperBound(NumericTraits< OutputType >::max())
{}
template< typename TInput, typename TOutput >
Clamp< TInput, TOutput >
::~Clamp() {}
template< typename TInput, typename TOutput >
typename Clamp< TInput, TOutput >::OutputType
Clamp< TInput, TOutput >
::GetLowerBound() const
{ return m_LowerBound; }
template< typename TInput, typename TOutput >
typename Clamp< TInput, TOutput >::OutputType
Clamp< TInput, TOutput >
::GetUpperBound() const
{ return m_UpperBound; }
template< typename TInput, typename TOutput >
void
Clamp< TInput, TOutput >
::SetBounds( const OutputType lowerBound, const OutputType upperBound)
{
if(lowerBound > upperBound)
{
itkGenericExceptionMacro("invalid bounds: [" << lowerBound << "; " << upperBound << "]");
}
m_LowerBound = lowerBound;
m_UpperBound = upperBound;
}
template< typename TInput, typename TOutput >
bool
Clamp< TInput, TOutput >
::operator!=( const Self & other ) const
{
return m_UpperBound != other.m_UpperBound
|| m_LowerBound != other.m_LowerBound;
}
template< typename TInput, typename TOutput >
bool
Clamp< TInput, TOutput >
::operator==( const Self & other ) const
{
return !(*this != other);
}
} // end namespace Functor
template <typename TInputImage, typename TOutputImage>
ClampImageFilter< TInputImage, TOutputImage >
::ClampImageFilter() {}
template <typename TInputImage, typename TOutputImage>
typename ClampImageFilter< TInputImage, TOutputImage >::OutputPixelType
ClampImageFilter< TInputImage, TOutputImage >
::GetLowerBound() const
{
return this->GetFunctor().GetLowerBound();
}
template <typename TInputImage, typename TOutputImage>
typename ClampImageFilter< TInputImage, TOutputImage >::OutputPixelType
ClampImageFilter< TInputImage, TOutputImage >
::GetUpperBound() const
{
return this->GetFunctor().GetUpperBound();
}
template <typename TInputImage, typename TOutputImage>
void
ClampImageFilter< TInputImage, TOutputImage >
::SetBounds(const OutputPixelType lowerBound, const OutputPixelType upperBound)
{
if ( Math::ExactlyEquals(lowerBound, this->GetFunctor().GetLowerBound()) && Math::ExactlyEquals(upperBound, this->GetFunctor().GetUpperBound()))
{
return;
}
this->GetFunctor().SetBounds(lowerBound, upperBound);
this->Modified();
}
template <typename TInputImage, typename TOutputImage>
void
ClampImageFilter< TInputImage, TOutputImage >
::GenerateData()
{
if( this->GetInPlace() && this->CanRunInPlace()
&& this->GetLowerBound() <= NumericTraits< OutputPixelType >::NonpositiveMin()
&& this->GetUpperBound() >= NumericTraits< OutputPixelType >::max() )
{
// If the filter is asked to run in-place, is able to run in-place,
// and the specified bounds are equal to the output-type limits,
// then there is nothing to do. To avoid iterating over all the pixels for
// nothing, graft the input to the output, generate a fake progress and exit.
this->AllocateOutputs();
ProgressReporter progress(this, 0, 1);
return;
}
Superclass::GenerateData();
}
template <typename TInputImage, typename TOutputImage>
void
ClampImageFilter< TInputImage, TOutputImage >
::PrintSelf(std::ostream & os, Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << "Lower bound: "
<< static_cast< typename NumericTraits< OutputPixelType >::PrintType >( this->GetLowerBound() ) << std::endl;
os << indent << "Upper bound: "
<< static_cast< typename NumericTraits< OutputPixelType >::PrintType >( this->GetUpperBound() ) << std::endl;
}
}
#endif
|
/**
* Copyright (c) 2016 Dallin Wellington
*
*/
#include <gtest/gtest.h>
#include <Math/Vector.h>
#include <Math/Matrix4x4.h>
using namespace Monsoon::Math;
// --------------------------------------
// Vector2 Tests
// --------------------------------------
TEST(Vector2, Magnitude) {
Vector2 vec = Vector2(10.0f, 5.0f);
EXPECT_EQ(sqrt((10.0f * 10.0f) + (5.0f * 5.0f)), vec.Magnitude());
}
TEST(Vector2, Dot) {
Vector2 vec1 = Vector2(10.0f, 5.0f);
Vector2 vec2 = Vector2(2.0f, 7.0f);
EXPECT_EQ((10.0f * 2.0f) + (5.0f * 7.0f), vec1 * vec2);
}
TEST(Vector2, Projection) {
Vector2 vec1 = Vector2(1.0f, 100.0f);
Vector2 vec2 = Vector2(100.0f, 0.0f);
EXPECT_EQ(1.0f, vec1.Proj(vec2).Magnitude());
}
TEST(Vector2, Perpendicular) {
Vector2 vec1 = Vector2(1.0f, 100.0f);
Vector2 vec2 = Vector2(100.0f, 0.0f);
EXPECT_EQ(100.0f, vec1.Perp(vec2).Magnitude());
}
TEST(Vector2, Unit) {
Vector2 vec = Vector2(10.0f, 5.0f);
//
// Unit Vector Definition:
//
// Let v = <x, y>
// |<x, y>| = <x/|v|,y/|v|>
//
EXPECT_EQ((10.0f / vec.Magnitude()), vec.Unit().mX);
EXPECT_EQ((5.0f / vec.Magnitude()), vec.Unit().mY);
}
TEST(Vector2, VestorAddition) {
Vector2 vec = Vector2(10.0f, 5.0f) + Vector2(2.0f, 7.0f);
EXPECT_EQ(12, vec.mX);
EXPECT_EQ(12, vec.mY);
}
TEST(Vector2, VectorSubtraction) {
Vector2 vec = Vector2(10.0f, 5.0f) - Vector2(2.0f, 7.0f);
EXPECT_EQ(8.0f, vec.mX);
EXPECT_EQ(-2.0f, vec.mY);
}
TEST(Vector2, ScalarMultiplication) {
Vector2 vec = Vector2(10.0f, 5.0f) * 2.0f;
EXPECT_EQ(20.0f, vec.mX);
EXPECT_EQ(10.0f, vec.mY);
}
TEST(Vector2, ScalarDivision) {
Vector2 vec = Vector2(10.0f, 5.0f) / 2.0f;
EXPECT_EQ(5.0f, vec.mX);
EXPECT_EQ((5.0f / 2.0f), vec.mY);
}
// --------------------------------------
// Vector3 Tests
// --------------------------------------
TEST(Vector3, Magnitude) {
Vector3 vec = Vector3(10.0f, 5.0f, 0.0f);
EXPECT_EQ(sqrt((10.0f * 10.0f) + (5.0f * 5.0f)), vec.Magnitude());
}
TEST(Vector3, Dot) {
Vector3 vec1 = Vector3(10.0f, 5.0f, 0.0f);
Vector3 vec2 = Vector3(2.0f, 7.0f, 0.0f);
EXPECT_EQ((10.0f * 2.0f) + (5.0f * 7.0f), vec1 * vec2);
}
TEST(Vector3, Projection) {
Vector3 vec1 = Vector3(1.0f, 100.0f, 0.0f);
Vector3 vec2 = Vector3(100.0f, 0.0f, 0.0f);
EXPECT_EQ(1.0f, vec1.Proj(vec2).Magnitude());
}
TEST(Vector3, Perpendicular) {
Vector3 vec1 = Vector3(1.0f, 100.0f, 0.0f);
Vector3 vec2 = Vector3(100.0f, 0.0f, 0.0f);
EXPECT_EQ(100.0f, vec1.Perp(vec2).Magnitude());
}
TEST(Vector3, Unit) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f);
//
// Unit Vector Definition:
//
// Let v = <x, y>
// |<x, y>| = <x/|v|,y/|v|>
//
EXPECT_EQ((10.0f / vec.Magnitude()), vec.Unit().mX);
EXPECT_EQ((5.0f / vec.Magnitude()), vec.Unit().mY);
EXPECT_EQ((2.0f / vec.Magnitude()), vec.Unit().mZ);
}
TEST(Vector3, VestorAddition) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) + Vector3(2.0f, 7.0f, -1.0f);
EXPECT_EQ(12.0f, vec.mX);
EXPECT_EQ(12.0f, vec.mY);
EXPECT_EQ(1.0f, vec.mZ);
}
TEST(Vector3, VectorSubtraction) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) - Vector3(2.0f, 7.0f, -1.0f);
EXPECT_EQ(8.0f, vec.mX);
EXPECT_EQ(-2.0f, vec.mY);
EXPECT_EQ(3.0f, vec.mZ);
}
TEST(Vector3, ScalarMultiplication) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) * 2.0f;
EXPECT_EQ(20.0f, vec.mX);
EXPECT_EQ(10.0f, vec.mY);
EXPECT_EQ(4.0f, vec.mZ);
}
TEST(Vector3, ScalarDivision) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) / 2.0f;
EXPECT_EQ(5.0f, vec.mX);
EXPECT_EQ((5.0f / 2.0f), vec.mY);
EXPECT_EQ(1.0f, vec.mZ);
}
// --------------------------------------
// Vector4 Tests
// --------------------------------------
// --------------------------------------
// Matrix4x4 Tests
// --------------------------------------
/*
* [I] * [I] = [I]
*/
TEST(Matrix4x4, IdentitySquared) {
Matrix4x4 m1, m2;
Matrix4x4 m3 = m1 * m2;
EXPECT_EQ(1.0f, m3(0,0));
EXPECT_EQ(1.0f, m3(1,1));
EXPECT_EQ(1.0f, m3(2,2));
EXPECT_EQ(1.0f, m3(3,3));
}
/*
* [A] * [I] = [I] * [A] = [A]
*/
TEST(Matrix4x4, IdentityMultiplicationProperty) {
float matrix[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 10.0f, -30.0f, 50.0f, 1.0f }
};
Matrix4x4 m1(matrix);
Matrix4x4 i;
Matrix4x4 left = m1 * i;
Matrix4x4 right = i * m1;
EXPECT_EQ(true, m1 == left);
EXPECT_EQ(true, m1 == right);
}
/*
* Test transpose functionality.
*/
TEST(Matrix4x4, Transpose) {
float matrix[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 10.0f, -30.0f, 50.0f, 1.0f }
};
float matrixT[4][4] = {
{ 1.0f, 0.0f, 0.0f, 10.0f },
{ 0.0f, 1.0f, 0.0f, -30.0f },
{ 0.0f, 0.0f, 1.0f, 50.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
Matrix4x4 m1(matrix);
Matrix4x4 m2(matrixT);
EXPECT_EQ(true, m2 == m1.GetTranspose());
m1.Transpose();
EXPECT_EQ(true, m2 == m1);
}
/*
* [I]^T = [I]
*/
TEST(Matrix4x4, IdentityTransposeProperty)
{
Matrix4x4 m1;
EXPECT_EQ(true, m1 == m1.GetTranspose());
m1.Transpose();
EXPECT_EQ(true, Matrix4x4() == m1);
}
Wrote test for transpose multiplication property. (A^T)(B^T)(C^T)==(ABC)^T
/**
* Copyright (c) 2016 Dallin Wellington
*
*/
#include <gtest/gtest.h>
#include <Math/Vector.h>
#include <Math/Matrix4x4.h>
using namespace Monsoon::Math;
// --------------------------------------
// Vector2 Tests
// --------------------------------------
TEST(Vector2, Magnitude) {
Vector2 vec = Vector2(10.0f, 5.0f);
EXPECT_EQ(sqrt((10.0f * 10.0f) + (5.0f * 5.0f)), vec.Magnitude());
}
TEST(Vector2, Dot) {
Vector2 vec1 = Vector2(10.0f, 5.0f);
Vector2 vec2 = Vector2(2.0f, 7.0f);
EXPECT_EQ((10.0f * 2.0f) + (5.0f * 7.0f), vec1 * vec2);
}
TEST(Vector2, Projection) {
Vector2 vec1 = Vector2(1.0f, 100.0f);
Vector2 vec2 = Vector2(100.0f, 0.0f);
EXPECT_EQ(1.0f, vec1.Proj(vec2).Magnitude());
}
TEST(Vector2, Perpendicular) {
Vector2 vec1 = Vector2(1.0f, 100.0f);
Vector2 vec2 = Vector2(100.0f, 0.0f);
EXPECT_EQ(100.0f, vec1.Perp(vec2).Magnitude());
}
TEST(Vector2, Unit) {
Vector2 vec = Vector2(10.0f, 5.0f);
//
// Unit Vector Definition:
//
// Let v = <x, y>
// |<x, y>| = <x/|v|,y/|v|>
//
EXPECT_EQ((10.0f / vec.Magnitude()), vec.Unit().mX);
EXPECT_EQ((5.0f / vec.Magnitude()), vec.Unit().mY);
}
TEST(Vector2, VestorAddition) {
Vector2 vec = Vector2(10.0f, 5.0f) + Vector2(2.0f, 7.0f);
EXPECT_EQ(12, vec.mX);
EXPECT_EQ(12, vec.mY);
}
TEST(Vector2, VectorSubtraction) {
Vector2 vec = Vector2(10.0f, 5.0f) - Vector2(2.0f, 7.0f);
EXPECT_EQ(8.0f, vec.mX);
EXPECT_EQ(-2.0f, vec.mY);
}
TEST(Vector2, ScalarMultiplication) {
Vector2 vec = Vector2(10.0f, 5.0f) * 2.0f;
EXPECT_EQ(20.0f, vec.mX);
EXPECT_EQ(10.0f, vec.mY);
}
TEST(Vector2, ScalarDivision) {
Vector2 vec = Vector2(10.0f, 5.0f) / 2.0f;
EXPECT_EQ(5.0f, vec.mX);
EXPECT_EQ((5.0f / 2.0f), vec.mY);
}
// --------------------------------------
// Vector3 Tests
// --------------------------------------
TEST(Vector3, Magnitude) {
Vector3 vec = Vector3(10.0f, 5.0f, 0.0f);
EXPECT_EQ(sqrt((10.0f * 10.0f) + (5.0f * 5.0f)), vec.Magnitude());
}
TEST(Vector3, Dot) {
Vector3 vec1 = Vector3(10.0f, 5.0f, 0.0f);
Vector3 vec2 = Vector3(2.0f, 7.0f, 0.0f);
EXPECT_EQ((10.0f * 2.0f) + (5.0f * 7.0f), vec1 * vec2);
}
TEST(Vector3, Projection) {
Vector3 vec1 = Vector3(1.0f, 100.0f, 0.0f);
Vector3 vec2 = Vector3(100.0f, 0.0f, 0.0f);
EXPECT_EQ(1.0f, vec1.Proj(vec2).Magnitude());
}
TEST(Vector3, Perpendicular) {
Vector3 vec1 = Vector3(1.0f, 100.0f, 0.0f);
Vector3 vec2 = Vector3(100.0f, 0.0f, 0.0f);
EXPECT_EQ(100.0f, vec1.Perp(vec2).Magnitude());
}
TEST(Vector3, Unit) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f);
//
// Unit Vector Definition:
//
// Let v = <x, y>
// |<x, y>| = <x/|v|,y/|v|>
//
EXPECT_EQ((10.0f / vec.Magnitude()), vec.Unit().mX);
EXPECT_EQ((5.0f / vec.Magnitude()), vec.Unit().mY);
EXPECT_EQ((2.0f / vec.Magnitude()), vec.Unit().mZ);
}
TEST(Vector3, VestorAddition) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) + Vector3(2.0f, 7.0f, -1.0f);
EXPECT_EQ(12.0f, vec.mX);
EXPECT_EQ(12.0f, vec.mY);
EXPECT_EQ(1.0f, vec.mZ);
}
TEST(Vector3, VectorSubtraction) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) - Vector3(2.0f, 7.0f, -1.0f);
EXPECT_EQ(8.0f, vec.mX);
EXPECT_EQ(-2.0f, vec.mY);
EXPECT_EQ(3.0f, vec.mZ);
}
TEST(Vector3, ScalarMultiplication) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) * 2.0f;
EXPECT_EQ(20.0f, vec.mX);
EXPECT_EQ(10.0f, vec.mY);
EXPECT_EQ(4.0f, vec.mZ);
}
TEST(Vector3, ScalarDivision) {
Vector3 vec = Vector3(10.0f, 5.0f, 2.0f) / 2.0f;
EXPECT_EQ(5.0f, vec.mX);
EXPECT_EQ((5.0f / 2.0f), vec.mY);
EXPECT_EQ(1.0f, vec.mZ);
}
// --------------------------------------
// Vector4 Tests
// --------------------------------------
// --------------------------------------
// Matrix4x4 Tests
// --------------------------------------
/*
* [I] * [I] = [I]
*/
TEST(Matrix4x4, IdentitySquared) {
Matrix4x4 m1, m2;
Matrix4x4 m3 = m1 * m2;
EXPECT_EQ(1.0f, m3(0,0));
EXPECT_EQ(1.0f, m3(1,1));
EXPECT_EQ(1.0f, m3(2,2));
EXPECT_EQ(1.0f, m3(3,3));
}
/*
* [A] * [I] = [I] * [A] = [A]
*/
TEST(Matrix4x4, IdentityMultiplicationProperty) {
float matrix[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 10.0f, -30.0f, 50.0f, 1.0f }
};
Matrix4x4 m1(matrix);
Matrix4x4 i;
Matrix4x4 left = m1 * i;
Matrix4x4 right = i * m1;
EXPECT_EQ(true, m1 == left);
EXPECT_EQ(true, m1 == right);
}
/*
* Test transpose functionality.
*/
TEST(Matrix4x4, Transpose) {
float matrix[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 10.0f, -30.0f, 50.0f, 1.0f }
};
float matrixT[4][4] = {
{ 1.0f, 0.0f, 0.0f, 10.0f },
{ 0.0f, 1.0f, 0.0f, -30.0f },
{ 0.0f, 0.0f, 1.0f, 50.0f },
{ 0.0f, 0.0f, 0.0f, 1.0f }
};
Matrix4x4 m1(matrix);
Matrix4x4 m2(matrixT);
EXPECT_EQ(true, m2 == m1.GetTranspose());
m1.Transpose();
EXPECT_EQ(true, m2 == m1);
}
/*
* [I]^T = [I]
*/
TEST(Matrix4x4, IdentityTransposeProperty)
{
Matrix4x4 m1;
EXPECT_EQ(true, m1 == m1.GetTranspose());
m1.Transpose();
EXPECT_EQ(true, Matrix4x4() == m1);
}
/*
* [A]^T*[B]^T*[C]^T = (ABC)^T
*/
TEST(Matrix4x4, TransposeMultiplicationProperty)
{
float matrix[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 10.0f, -30.0f, 50.0f, 1.0f }
};
float matrix2[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ 40.0f, 30.0f, 150.0f, 1.0f }
};
float matrix3[4][4] = {
{ 1.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, 1.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, 1.0f, 0.0f },
{ -310.0f, 90.0f, 45.0f, 1.0f }
};
Matrix4x4 m1(matrix), m2(matrix2), m3(matrix3);
Matrix4x4 m4 = (m1 * m2 * m3).GetTranspose(); // ABC^T
Matrix4x4 m5 = m1.GetTranspose() * m2.GetTranspose() * m3.GetTranspose();
EXPECT_EQ(true, m4 == m5);
} |
//===-- AppleObjCRuntimeV2.cpp ----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#include <stdint.h>
// C++ Includes
#include <string>
#include <vector>
// Other libraries and framework includes
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
// Project includes
#include "lldb/Core/ClangForward.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h"
#include "lldb/Expression/UtilityFunction.h"
#include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "AppleObjCClassDescriptorV2.h"
#include "AppleObjCDeclVendor.h"
#include "AppleObjCRuntimeV2.h"
#include "AppleObjCTrampolineHandler.h"
#include "AppleObjCTypeEncodingParser.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
#include <vector>
using namespace lldb;
using namespace lldb_private;
// 2 second timeout when running utility functions
static constexpr std::chrono::seconds g_utility_function_timeout(2);
static const char *g_get_dynamic_class_info_name =
"__lldb_apple_objc_v2_get_dynamic_class_info";
// Testing using the new C++11 raw string literals. If this breaks GCC then we
// will
// need to revert to the code above...
static const char *g_get_dynamic_class_info_body = R"(
extern "C"
{
size_t strlen(const char *);
char *strncpy (char * s1, const char * s2, size_t n);
int printf(const char * format, ...);
}
#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)
typedef struct _NXMapTable {
void *prototype;
unsigned num_classes;
unsigned num_buckets_minus_one;
void *buckets;
} NXMapTable;
#define NX_MAPNOTAKEY ((void *)(-1))
typedef struct BucketInfo
{
const char *name_ptr;
Class isa;
} BucketInfo;
struct ClassInfo
{
Class isa;
uint32_t hash;
} __attribute__((__packed__));
uint32_t
__lldb_apple_objc_v2_get_dynamic_class_info (void *gdb_objc_realized_classes_ptr,
void *class_infos_ptr,
uint32_t class_infos_byte_size,
uint32_t should_log)
{
DEBUG_PRINTF ("gdb_objc_realized_classes_ptr = %p\n", gdb_objc_realized_classes_ptr);
DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size);
const NXMapTable *grc = (const NXMapTable *)gdb_objc_realized_classes_ptr;
if (grc)
{
const unsigned num_classes = grc->num_classes;
if (class_infos_ptr)
{
const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
BucketInfo *buckets = (BucketInfo *)grc->buckets;
uint32_t idx = 0;
for (unsigned i=0; i<=grc->num_buckets_minus_one; ++i)
{
if (buckets[i].name_ptr != NX_MAPNOTAKEY)
{
if (idx < max_class_infos)
{
const char *s = buckets[i].name_ptr;
uint32_t h = 5381;
for (unsigned char c = *s; c; c = *++s)
h = ((h << 5) + h) + c;
class_infos[idx].hash = h;
class_infos[idx].isa = buckets[i].isa;
}
++idx;
}
}
if (idx < max_class_infos)
{
class_infos[idx].isa = NULL;
class_infos[idx].hash = 0;
}
}
return num_classes;
}
return 0;
}
)";
static const char *g_get_shared_cache_class_info_name =
"__lldb_apple_objc_v2_get_shared_cache_class_info";
// Testing using the new C++11 raw string literals. If this breaks GCC then we
// will
// need to revert to the code above...
static const char *g_get_shared_cache_class_info_body = R"(
extern "C"
{
const char *class_getName(void *objc_class);
size_t strlen(const char *);
char *strncpy (char * s1, const char * s2, size_t n);
int printf(const char * format, ...);
}
#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)
struct objc_classheader_t {
int32_t clsOffset;
int32_t hiOffset;
};
struct objc_clsopt_t {
uint32_t capacity;
uint32_t occupied;
uint32_t shift;
uint32_t mask;
uint32_t zero;
uint32_t unused;
uint64_t salt;
uint32_t scramble[256];
uint8_t tab[0]; // tab[mask+1]
// uint8_t checkbytes[capacity];
// int32_t offset[capacity];
// objc_classheader_t clsOffsets[capacity];
// uint32_t duplicateCount;
// objc_classheader_t duplicateOffsets[duplicateCount];
};
struct objc_opt_t {
uint32_t version;
int32_t selopt_offset;
int32_t headeropt_offset;
int32_t clsopt_offset;
};
struct objc_opt_v14_t {
uint32_t version;
uint32_t flags;
int32_t selopt_offset;
int32_t headeropt_offset;
int32_t clsopt_offset;
};
struct ClassInfo
{
Class isa;
uint32_t hash;
} __attribute__((__packed__));
uint32_t
__lldb_apple_objc_v2_get_shared_cache_class_info (void *objc_opt_ro_ptr,
void *class_infos_ptr,
uint32_t class_infos_byte_size,
uint32_t should_log)
{
uint32_t idx = 0;
DEBUG_PRINTF ("objc_opt_ro_ptr = %p\n", objc_opt_ro_ptr);
DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
DEBUG_PRINTF ("class_infos_byte_size = %u (%llu class infos)\n", class_infos_byte_size, (uint64_t)(class_infos_byte_size/sizeof(ClassInfo)));
if (objc_opt_ro_ptr)
{
const objc_opt_t *objc_opt = (objc_opt_t *)objc_opt_ro_ptr;
const objc_opt_v14_t* objc_opt_v14 = (objc_opt_v14_t*)objc_opt_ro_ptr;
const bool is_v14_format = objc_opt->version >= 14;
if (is_v14_format)
{
DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt_v14->version);
DEBUG_PRINTF ("objc_opt->flags = %u\n", objc_opt_v14->flags);
DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt_v14->selopt_offset);
DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt_v14->headeropt_offset);
DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt_v14->clsopt_offset);
}
else
{
DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt->version);
DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt->selopt_offset);
DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt->headeropt_offset);
DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt->clsopt_offset);
}
if (objc_opt->version == 12 || objc_opt->version == 13 || objc_opt->version == 14 || objc_opt->version == 15)
{
const objc_clsopt_t* clsopt = NULL;
if (is_v14_format)
clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt_v14 + objc_opt_v14->clsopt_offset);
else
clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt + objc_opt->clsopt_offset);
const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
DEBUG_PRINTF("max_class_infos = %llu\n", (uint64_t)max_class_infos);
ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
int32_t invalidEntryOffset = 0;
// this is safe to do because the version field order is invariant
if (objc_opt->version == 12)
invalidEntryOffset = 16;
const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1];
const int32_t *offsets = (const int32_t *)(checkbytes + clsopt->capacity);
const objc_classheader_t *classOffsets = (const objc_classheader_t *)(offsets + clsopt->capacity);
DEBUG_PRINTF ("clsopt->capacity = %u\n", clsopt->capacity);
DEBUG_PRINTF ("clsopt->mask = 0x%8.8x\n", clsopt->mask);
DEBUG_PRINTF ("classOffsets = %p\n", classOffsets);
DEBUG_PRINTF("invalidEntryOffset = %d\n", invalidEntryOffset);
for (uint32_t i=0; i<clsopt->capacity; ++i)
{
const int32_t clsOffset = classOffsets[i].clsOffset;
DEBUG_PRINTF("clsOffset[%u] = %u\n", i, clsOffset);
if (clsOffset & 1)
{
DEBUG_PRINTF("clsOffset & 1\n");
continue; // duplicate
}
else if (clsOffset == invalidEntryOffset)
{
DEBUG_PRINTF("clsOffset == invalidEntryOffset\n");
continue; // invalid offset
}
if (class_infos && idx < max_class_infos)
{
class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
const char *name = class_getName (class_infos[idx].isa);
DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
// Hash the class name so we don't have to read it
const char *s = name;
uint32_t h = 5381;
for (unsigned char c = *s; c; c = *++s)
h = ((h << 5) + h) + c;
class_infos[idx].hash = h;
}
else
{
DEBUG_PRINTF("not(class_infos && idx < max_class_infos)\n");
}
++idx;
}
const uint32_t *duplicate_count_ptr = (uint32_t *)&classOffsets[clsopt->capacity];
const uint32_t duplicate_count = *duplicate_count_ptr;
const objc_classheader_t *duplicateClassOffsets = (const objc_classheader_t *)(&duplicate_count_ptr[1]);
DEBUG_PRINTF ("duplicate_count = %u\n", duplicate_count);
DEBUG_PRINTF ("duplicateClassOffsets = %p\n", duplicateClassOffsets);
for (uint32_t i=0; i<duplicate_count; ++i)
{
const int32_t clsOffset = duplicateClassOffsets[i].clsOffset;
if (clsOffset & 1)
continue; // duplicate
else if (clsOffset == invalidEntryOffset)
continue; // invalid offset
if (class_infos && idx < max_class_infos)
{
class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
const char *name = class_getName (class_infos[idx].isa);
DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
// Hash the class name so we don't have to read it
const char *s = name;
uint32_t h = 5381;
for (unsigned char c = *s; c; c = *++s)
h = ((h << 5) + h) + c;
class_infos[idx].hash = h;
}
++idx;
}
}
DEBUG_PRINTF ("%u class_infos\n", idx);
DEBUG_PRINTF ("done\n");
}
return idx;
}
)";
static uint64_t
ExtractRuntimeGlobalSymbol(Process *process, ConstString name,
const ModuleSP &module_sp, Error &error,
bool read_value = true, uint8_t byte_size = 0,
uint64_t default_value = LLDB_INVALID_ADDRESS,
SymbolType sym_type = lldb::eSymbolTypeData) {
if (!process) {
error.SetErrorString("no process");
return default_value;
}
if (!module_sp) {
error.SetErrorString("no module");
return default_value;
}
if (!byte_size)
byte_size = process->GetAddressByteSize();
const Symbol *symbol =
module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData);
if (symbol && symbol->ValueIsAddress()) {
lldb::addr_t symbol_load_addr =
symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
if (read_value)
return process->ReadUnsignedIntegerFromMemory(
symbol_load_addr, byte_size, default_value, error);
else
return symbol_load_addr;
} else {
error.SetErrorString("symbol address invalid");
return default_value;
}
} else {
error.SetErrorString("no symbol");
return default_value;
}
}
AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process,
const ModuleSP &objc_module_sp)
: AppleObjCRuntime(process), m_get_class_info_code(),
m_get_class_info_args(LLDB_INVALID_ADDRESS),
m_get_class_info_args_mutex(), m_get_shared_cache_class_info_code(),
m_get_shared_cache_class_info_args(LLDB_INVALID_ADDRESS),
m_get_shared_cache_class_info_args_mutex(), m_decl_vendor_ap(),
m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS), m_hash_signature(),
m_has_object_getClass(false), m_loaded_objc_opt(false),
m_non_pointer_isa_cache_ap(
NonPointerISACache::CreateInstance(*this, objc_module_sp)),
m_tagged_pointer_vendor_ap(
TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)),
m_encoding_to_type_sp(), m_noclasses_warning_emitted(false),
m_CFBoolean_values() {
static const ConstString g_gdb_object_getClass("gdb_object_getClass");
m_has_object_getClass = (objc_module_sp->FindFirstSymbolWithNameAndType(
g_gdb_object_getClass, eSymbolTypeCode) != NULL);
}
bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address,
Value::ValueType &value_type, bool allow_swift) {
// We should never get here with a null process...
assert(m_process != NULL);
// The Runtime is attached to a particular process, you shouldn't pass in a
// value from another process.
// Note, however, the process might be NULL (e.g. if the value was made with
// SBTarget::EvaluateExpression...)
// in which case it is sufficient if the target's match:
Process *process = in_value.GetProcessSP().get();
if (process)
assert(process == m_process);
else
assert(in_value.GetTargetSP().get() == m_process->CalculateTarget().get());
class_type_or_name.Clear();
value_type = Value::ValueType::eValueTypeScalar;
// Make sure we can have a dynamic value before starting...
if (CouldHaveDynamicValue(in_value, allow_swift)) {
// First job, pull out the address at 0 offset from the object That will be
// the ISA pointer.
ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(in_value));
if (objc_class_sp) {
const addr_t object_ptr = in_value.GetPointerValue();
address.SetRawAddress(object_ptr);
ConstString class_name(objc_class_sp->GetClassName());
class_type_or_name.SetName(class_name);
TypeSP type_sp(objc_class_sp->GetType());
if (type_sp)
class_type_or_name.SetTypeSP(type_sp);
else {
type_sp = LookupInCompleteClassCache(class_name);
if (type_sp) {
objc_class_sp->SetType(type_sp);
class_type_or_name.SetTypeSP(type_sp);
} else {
// try to go for a CompilerType at least
DeclVendor *vendor = GetDeclVendor();
if (vendor) {
std::vector<clang::NamedDecl *> decls;
if (vendor->FindDecls(class_name, false, 1, decls) && decls.size())
class_type_or_name.SetCompilerType(
ClangASTContext::GetTypeForDecl(decls[0]));
}
}
}
}
}
return class_type_or_name.IsEmpty() == false;
}
bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
ValueObject &in_value, DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address,
Value::ValueType &value_type) {
return GetDynamicTypeAndAddress(in_value, use_dynamic, class_type_or_name,
address, value_type,
/* allow_swift = */ false);
}
//------------------------------------------------------------------
// Static Functions
//------------------------------------------------------------------
LanguageRuntime *AppleObjCRuntimeV2::CreateInstance(Process *process,
LanguageType language) {
// FIXME: This should be a MacOS or iOS process, and we need to look for the
// OBJC section to make
// sure we aren't using the V1 runtime.
if (language == eLanguageTypeObjC) {
ModuleSP objc_module_sp;
if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
ObjCRuntimeVersions::eAppleObjC_V2)
return new AppleObjCRuntimeV2(process, objc_module_sp);
else
return NULL;
} else
return NULL;
}
static OptionDefinition g_objc_classtable_dump_options[] = {
{LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument,
nullptr, nullptr, 0, eArgTypeNone,
"Print ivar and method information in detail"}};
class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed {
public:
class CommandOptions : public Options {
public:
CommandOptions() : Options(), m_verbose(false, false) {}
~CommandOptions() override = default;
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override {
Error error;
const int short_option = m_getopt_table[option_idx].val;
switch (short_option) {
case 'v':
m_verbose.SetCurrentValue(true);
m_verbose.SetOptionWasSet();
break;
default:
error.SetErrorStringWithFormat("unrecognized short option '%c'",
short_option);
break;
}
return error;
}
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose.Clear();
}
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_objc_classtable_dump_options);
}
OptionValueBoolean m_verbose;
};
CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter)
: CommandObjectParsed(
interpreter, "dump", "Dump information on Objective-C classes "
"known to the current process.",
"language objc class-table dump",
eCommandRequiresProcess | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused),
m_options() {
CommandArgumentEntry arg;
CommandArgumentData index_arg;
// Define the first (and only) variant of this arg.
index_arg.arg_type = eArgTypeRegularExpression;
index_arg.arg_repetition = eArgRepeatOptional;
// There is only one variant this argument could be; put it into the
// argument entry.
arg.push_back(index_arg);
// Push the data for the first argument into the m_arguments vector.
m_arguments.push_back(arg);
}
~CommandObjectObjC_ClassTable_Dump() override = default;
Options *GetOptions() override { return &m_options; }
protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
std::unique_ptr<RegularExpression> regex_up;
switch (command.GetArgumentCount()) {
case 0:
break;
case 1: {
regex_up.reset(new RegularExpression());
if (!regex_up->Compile(llvm::StringRef::withNullAsEmpty(
command.GetArgumentAtIndex(0)))) {
result.AppendError(
"invalid argument - please provide a valid regular expression");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
break;
}
default: {
result.AppendError("please provide 0 or 1 arguments");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
Process *process = m_exe_ctx.GetProcessPtr();
ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
if (objc_runtime) {
auto iterators_pair = objc_runtime->GetDescriptorIteratorPair();
auto iterator = iterators_pair.first;
auto &std_out = result.GetOutputStream();
for (; iterator != iterators_pair.second; iterator++) {
if (iterator->second) {
const char *class_name =
iterator->second->GetClassName().AsCString("<unknown>");
if (regex_up && class_name &&
!regex_up->Execute(llvm::StringRef(class_name)))
continue;
std_out.Printf("isa = 0x%" PRIx64, iterator->first);
std_out.Printf(" name = %s", class_name);
std_out.Printf(" instance size = %" PRIu64,
iterator->second->GetInstanceSize());
std_out.Printf(" num ivars = %" PRIuPTR,
(uintptr_t)iterator->second->GetNumIVars());
if (auto superclass = iterator->second->GetSuperclass()) {
std_out.Printf(" superclass = %s",
superclass->GetClassName().AsCString("<unknown>"));
}
std_out.Printf("\n");
if (m_options.m_verbose) {
for (size_t i = 0; i < iterator->second->GetNumIVars(); i++) {
auto ivar = iterator->second->GetIVarAtIndex(i);
std_out.Printf(
" ivar name = %s type = %s size = %" PRIu64
" offset = %" PRId32 "\n",
ivar.m_name.AsCString("<unknown>"),
ivar.m_type.GetDisplayTypeName().AsCString("<unknown>"),
ivar.m_size, ivar.m_offset);
}
iterator->second->Describe(
nullptr,
[objc_runtime, &std_out](const char *name,
const char *type) -> bool {
std_out.Printf(" instance method name = %s type = %s\n",
name, type);
return false;
},
[objc_runtime, &std_out](const char *name,
const char *type) -> bool {
std_out.Printf(" class method name = %s type = %s\n", name,
type);
return false;
},
nullptr);
}
} else {
if (regex_up && !regex_up->Execute(llvm::StringRef()))
continue;
std_out.Printf("isa = 0x%" PRIx64 " has no associated class.\n",
iterator->first);
}
}
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true;
} else {
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
CommandOptions m_options;
};
class CommandObjectMultiwordObjC_TaggedPointer_Info
: public CommandObjectParsed {
public:
CommandObjectMultiwordObjC_TaggedPointer_Info(CommandInterpreter &interpreter)
: CommandObjectParsed(
interpreter, "info", "Dump information on a tagged pointer.",
"language objc tagged-pointer info",
eCommandRequiresProcess | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused) {
CommandArgumentEntry arg;
CommandArgumentData index_arg;
// Define the first (and only) variant of this arg.
index_arg.arg_type = eArgTypeAddress;
index_arg.arg_repetition = eArgRepeatPlus;
// There is only one variant this argument could be; put it into the
// argument entry.
arg.push_back(index_arg);
// Push the data for the first argument into the m_arguments vector.
m_arguments.push_back(arg);
}
~CommandObjectMultiwordObjC_TaggedPointer_Info() override = default;
protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
if (command.GetArgumentCount() == 0) {
result.AppendError("this command requires arguments");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
Process *process = m_exe_ctx.GetProcessPtr();
ExecutionContext exe_ctx(process);
ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
if (objc_runtime) {
ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor =
objc_runtime->GetTaggedPointerVendor();
if (tagged_ptr_vendor) {
for (size_t i = 0; i < command.GetArgumentCount(); i++) {
const char *arg_str = command.GetArgumentAtIndex(i);
if (!arg_str)
continue;
Error error;
lldb::addr_t arg_addr = Args::StringToAddress(
&exe_ctx, arg_str, LLDB_INVALID_ADDRESS, &error);
if (arg_addr == 0 || arg_addr == LLDB_INVALID_ADDRESS || error.Fail())
continue;
auto descriptor_sp = tagged_ptr_vendor->GetClassDescriptor(arg_addr);
if (!descriptor_sp)
continue;
uint64_t info_bits = 0;
uint64_t value_bits = 0;
uint64_t payload = 0;
if (descriptor_sp->GetTaggedPointerInfo(&info_bits, &value_bits,
&payload)) {
result.GetOutputStream().Printf(
"0x%" PRIx64 " is tagged.\n\tpayload = 0x%" PRIx64
"\n\tvalue = 0x%" PRIx64 "\n\tinfo bits = 0x%" PRIx64
"\n\tclass = %s\n",
(uint64_t)arg_addr, payload, value_bits, info_bits,
descriptor_sp->GetClassName().AsCString("<unknown>"));
} else {
result.GetOutputStream().Printf("0x%" PRIx64 " is not tagged.\n",
(uint64_t)arg_addr);
}
}
} else {
result.AppendError("current process has no tagged pointer support");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true;
} else {
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
};
class CommandObjectMultiwordObjC_ClassTable : public CommandObjectMultiword {
public:
CommandObjectMultiwordObjC_ClassTable(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "class-table",
"Commands for operating on the Objective-C class table.",
"class-table <subcommand> [<subcommand-options>]") {
LoadSubCommand(
"dump",
CommandObjectSP(new CommandObjectObjC_ClassTable_Dump(interpreter)));
}
~CommandObjectMultiwordObjC_ClassTable() override = default;
};
class CommandObjectMultiwordObjC_TaggedPointer : public CommandObjectMultiword {
public:
CommandObjectMultiwordObjC_TaggedPointer(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "tagged-pointer",
"Commands for operating on Objective-C tagged pointers.",
"class-table <subcommand> [<subcommand-options>]") {
LoadSubCommand(
"info",
CommandObjectSP(
new CommandObjectMultiwordObjC_TaggedPointer_Info(interpreter)));
}
~CommandObjectMultiwordObjC_TaggedPointer() override = default;
};
class CommandObjectMultiwordObjC : public CommandObjectMultiword {
public:
CommandObjectMultiwordObjC(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "objc",
"Commands for operating on the Objective-C language runtime.",
"objc <subcommand> [<subcommand-options>]") {
LoadSubCommand("class-table",
CommandObjectSP(
new CommandObjectMultiwordObjC_ClassTable(interpreter)));
LoadSubCommand("tagged-pointer",
CommandObjectSP(new CommandObjectMultiwordObjC_TaggedPointer(
interpreter)));
}
~CommandObjectMultiwordObjC() override = default;
};
void AppleObjCRuntimeV2::Initialize() {
PluginManager::RegisterPlugin(
GetPluginNameStatic(), "Apple Objective C Language Runtime - Version 2",
CreateInstance,
[](CommandInterpreter &interpreter) -> lldb::CommandObjectSP {
return CommandObjectSP(new CommandObjectMultiwordObjC(interpreter));
});
}
void AppleObjCRuntimeV2::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
}
lldb_private::ConstString AppleObjCRuntimeV2::GetPluginNameStatic() {
static ConstString g_name("apple-objc-v2");
return g_name;
}
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
lldb_private::ConstString AppleObjCRuntimeV2::GetPluginName() {
return GetPluginNameStatic();
}
uint32_t AppleObjCRuntimeV2::GetPluginVersion() { return 1; }
BreakpointResolverSP
AppleObjCRuntimeV2::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
bool throw_bp) {
BreakpointResolverSP resolver_sp;
if (throw_bp)
resolver_sp.reset(new BreakpointResolverName(
bkpt, "objc_exception_throw", eFunctionNameTypeBase,
eLanguageTypeUnknown, Breakpoint::Exact, 0, eLazyBoolNo));
// FIXME: We don't do catch breakpoints for ObjC yet.
// Should there be some way for the runtime to specify what it can do in this
// regard?
return resolver_sp;
}
UtilityFunction *AppleObjCRuntimeV2::CreateObjectChecker(const char *name) {
char check_function_code[2048];
int len = 0;
if (m_has_object_getClass) {
len = ::snprintf(check_function_code, sizeof(check_function_code),
"extern \"C\" void *gdb_object_getClass(void *); "
" \n"
"extern \"C\" int printf(const char *format, ...); "
" \n"
"extern \"C\" void "
" \n"
"%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) "
" \n"
"{ "
" \n"
" if ($__lldb_arg_obj == (void *)0) "
" \n"
" return; // nil is ok "
" \n"
" if (!gdb_object_getClass($__lldb_arg_obj)) "
" \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" else if ($__lldb_arg_selector != (void *)0) "
" \n"
" { "
" \n"
" signed char responds = (signed char) [(id) "
"$__lldb_arg_obj \n"
" "
"respondsToSelector: \n"
" (struct "
"objc_selector *) $__lldb_arg_selector]; \n"
" if (responds == (signed char) 0) "
" \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" } "
" \n"
"} "
" \n",
name);
} else {
len = ::snprintf(check_function_code, sizeof(check_function_code),
"extern \"C\" void *gdb_class_getClass(void *); "
" \n"
"extern \"C\" int printf(const char *format, ...); "
" \n"
"extern \"C\" void "
" \n"
"%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) "
" \n"
"{ "
" \n"
" if ($__lldb_arg_obj == (void *)0) "
" \n"
" return; // nil is ok "
" \n"
" void **$isa_ptr = (void **)$__lldb_arg_obj; "
" \n"
" if (*$isa_ptr == (void *)0 || "
"!gdb_class_getClass(*$isa_ptr)) \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" else if ($__lldb_arg_selector != (void *)0) "
" \n"
" { "
" \n"
" signed char responds = (signed char) [(id) "
"$__lldb_arg_obj \n"
" "
"respondsToSelector: \n"
" (struct "
"objc_selector *) $__lldb_arg_selector]; \n"
" if (responds == (signed char) 0) "
" \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" } "
" \n"
"} "
" \n",
name);
}
assert(len < (int)sizeof(check_function_code));
Error error;
return GetTargetRef().GetUtilityFunctionForLanguage(
check_function_code, eLanguageTypeObjC, name, error);
}
size_t AppleObjCRuntimeV2::GetByteOffsetForIvar(CompilerType &parent_ast_type,
const char *ivar_name) {
uint32_t ivar_offset = LLDB_INVALID_IVAR_OFFSET;
const char *class_name = parent_ast_type.GetConstTypeName().AsCString();
if (class_name && class_name[0] && ivar_name && ivar_name[0]) {
//----------------------------------------------------------------------
// Make the objective C V2 mangled name for the ivar offset from the
// class name and ivar name
//----------------------------------------------------------------------
std::string buffer("OBJC_IVAR_$_");
buffer.append(class_name);
buffer.push_back('.');
buffer.append(ivar_name);
ConstString ivar_const_str(buffer.c_str());
//----------------------------------------------------------------------
// Try to get the ivar offset address from the symbol table first using
// the name we created above
//----------------------------------------------------------------------
SymbolContextList sc_list;
Target &target = m_process->GetTarget();
target.GetImages().FindSymbolsWithNameAndType(ivar_const_str,
eSymbolTypeObjCIVar, sc_list);
addr_t ivar_offset_address = LLDB_INVALID_ADDRESS;
Error error;
SymbolContext ivar_offset_symbol;
if (sc_list.GetSize() == 1 &&
sc_list.GetContextAtIndex(0, ivar_offset_symbol)) {
if (ivar_offset_symbol.symbol)
ivar_offset_address =
ivar_offset_symbol.symbol->GetLoadAddress(&target);
}
//----------------------------------------------------------------------
// If we didn't get the ivar offset address from the symbol table, fall
// back to getting it from the runtime
//----------------------------------------------------------------------
if (ivar_offset_address == LLDB_INVALID_ADDRESS)
ivar_offset_address = LookupRuntimeSymbol(ivar_const_str);
if (ivar_offset_address != LLDB_INVALID_ADDRESS)
ivar_offset = m_process->ReadUnsignedIntegerFromMemory(
ivar_offset_address, 4, LLDB_INVALID_IVAR_OFFSET, error);
}
return ivar_offset;
}
// tagged pointers are special not-a-real-pointer values that contain both type
// and value information
// this routine attempts to check with as little computational effort as
// possible whether something
// could possibly be a tagged pointer - false positives are possible but false
// negatives shouldn't
bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) {
if (!m_tagged_pointer_vendor_ap)
return false;
return m_tagged_pointer_vendor_ap->IsPossibleTaggedPointer(ptr);
}
class RemoteNXMapTable {
public:
RemoteNXMapTable()
: m_count(0), m_num_buckets_minus_one(0),
m_buckets_ptr(LLDB_INVALID_ADDRESS), m_process(NULL),
m_end_iterator(*this, -1), m_load_addr(LLDB_INVALID_ADDRESS),
m_map_pair_size(0), m_invalid_key(0) {}
void Dump() {
printf("RemoteNXMapTable.m_load_addr = 0x%" PRIx64 "\n", m_load_addr);
printf("RemoteNXMapTable.m_count = %u\n", m_count);
printf("RemoteNXMapTable.m_num_buckets_minus_one = %u\n",
m_num_buckets_minus_one);
printf("RemoteNXMapTable.m_buckets_ptr = 0x%" PRIX64 "\n", m_buckets_ptr);
}
bool ParseHeader(Process *process, lldb::addr_t load_addr) {
m_process = process;
m_load_addr = load_addr;
m_map_pair_size = m_process->GetAddressByteSize() * 2;
m_invalid_key =
m_process->GetAddressByteSize() == 8 ? UINT64_MAX : UINT32_MAX;
Error err;
// This currently holds true for all platforms we support, but we might
// need to change this to use get the actually byte size of "unsigned"
// from the target AST...
const uint32_t unsigned_byte_size = sizeof(uint32_t);
// Skip the prototype as we don't need it (const struct +NXMapTablePrototype
// *prototype)
bool success = true;
if (load_addr == LLDB_INVALID_ADDRESS)
success = false;
else {
lldb::addr_t cursor = load_addr + m_process->GetAddressByteSize();
// unsigned count;
m_count = m_process->ReadUnsignedIntegerFromMemory(
cursor, unsigned_byte_size, 0, err);
if (m_count) {
cursor += unsigned_byte_size;
// unsigned nbBucketsMinusOne;
m_num_buckets_minus_one = m_process->ReadUnsignedIntegerFromMemory(
cursor, unsigned_byte_size, 0, err);
cursor += unsigned_byte_size;
// void *buckets;
m_buckets_ptr = m_process->ReadPointerFromMemory(cursor, err);
success = m_count > 0 && m_buckets_ptr != LLDB_INVALID_ADDRESS;
}
}
if (!success) {
m_count = 0;
m_num_buckets_minus_one = 0;
m_buckets_ptr = LLDB_INVALID_ADDRESS;
}
return success;
}
// const_iterator mimics NXMapState and its code comes from NXInitMapState and
// NXNextMapState.
typedef std::pair<ConstString, ObjCLanguageRuntime::ObjCISA> element;
friend class const_iterator;
class const_iterator {
public:
const_iterator(RemoteNXMapTable &parent, int index)
: m_parent(parent), m_index(index) {
AdvanceToValidIndex();
}
const_iterator(const const_iterator &rhs)
: m_parent(rhs.m_parent), m_index(rhs.m_index) {
// AdvanceToValidIndex() has been called by rhs already.
}
const_iterator &operator=(const const_iterator &rhs) {
// AdvanceToValidIndex() has been called by rhs already.
assert(&m_parent == &rhs.m_parent);
m_index = rhs.m_index;
return *this;
}
bool operator==(const const_iterator &rhs) const {
if (&m_parent != &rhs.m_parent)
return false;
if (m_index != rhs.m_index)
return false;
return true;
}
bool operator!=(const const_iterator &rhs) const {
return !(operator==(rhs));
}
const_iterator &operator++() {
AdvanceToValidIndex();
return *this;
}
const element operator*() const {
if (m_index == -1) {
// TODO find a way to make this an error, but not an assert
return element();
}
lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
size_t map_pair_size = m_parent.m_map_pair_size;
lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
Error err;
lldb::addr_t key =
m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
if (!err.Success())
return element();
lldb::addr_t value = m_parent.m_process->ReadPointerFromMemory(
pair_ptr + m_parent.m_process->GetAddressByteSize(), err);
if (!err.Success())
return element();
std::string key_string;
m_parent.m_process->ReadCStringFromMemory(key, key_string, err);
if (!err.Success())
return element();
return element(ConstString(key_string.c_str()),
(ObjCLanguageRuntime::ObjCISA)value);
}
private:
void AdvanceToValidIndex() {
if (m_index == -1)
return;
const lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
const size_t map_pair_size = m_parent.m_map_pair_size;
const lldb::addr_t invalid_key = m_parent.m_invalid_key;
Error err;
while (m_index--) {
lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
lldb::addr_t key =
m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
if (!err.Success()) {
m_index = -1;
return;
}
if (key != invalid_key)
return;
}
}
RemoteNXMapTable &m_parent;
int m_index;
};
const_iterator begin() {
return const_iterator(*this, m_num_buckets_minus_one + 1);
}
const_iterator end() { return m_end_iterator; }
uint32_t GetCount() const { return m_count; }
uint32_t GetBucketCount() const { return m_num_buckets_minus_one; }
lldb::addr_t GetBucketDataPointer() const { return m_buckets_ptr; }
lldb::addr_t GetTableLoadAddress() const { return m_load_addr; }
private:
// contents of _NXMapTable struct
uint32_t m_count;
uint32_t m_num_buckets_minus_one;
lldb::addr_t m_buckets_ptr;
lldb_private::Process *m_process;
const_iterator m_end_iterator;
lldb::addr_t m_load_addr;
size_t m_map_pair_size;
lldb::addr_t m_invalid_key;
};
AppleObjCRuntimeV2::HashTableSignature::HashTableSignature()
: m_count(0), m_num_buckets(0), m_buckets_ptr(0) {}
void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature(
const RemoteNXMapTable &hash_table) {
m_count = hash_table.GetCount();
m_num_buckets = hash_table.GetBucketCount();
m_buckets_ptr = hash_table.GetBucketDataPointer();
}
bool AppleObjCRuntimeV2::HashTableSignature::NeedsUpdate(
Process *process, AppleObjCRuntimeV2 *runtime,
RemoteNXMapTable &hash_table) {
if (!hash_table.ParseHeader(process, runtime->GetISAHashTablePointer())) {
return false; // Failed to parse the header, no need to update anything
}
// Check with out current signature and return true if the count,
// number of buckets or the hash table address changes.
if (m_count == hash_table.GetCount() &&
m_num_buckets == hash_table.GetBucketCount() &&
m_buckets_ptr == hash_table.GetBucketDataPointer()) {
// Hash table hasn't changed
return false;
}
// Hash table data has changed, we need to update
return true;
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::GetClassDescriptorFromISA(ObjCISA isa) {
ObjCLanguageRuntime::ClassDescriptorSP class_descriptor_sp;
if (m_non_pointer_isa_cache_ap.get())
class_descriptor_sp = m_non_pointer_isa_cache_ap->GetClassDescriptor(isa);
if (!class_descriptor_sp)
class_descriptor_sp = ObjCLanguageRuntime::GetClassDescriptorFromISA(isa);
return class_descriptor_sp;
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::GetClassDescriptor(ValueObject &valobj) {
ClassDescriptorSP objc_class_sp;
if (valobj.IsBaseClass()) {
ValueObject *parent = valobj.GetParent();
// if I am my own parent, bail out of here fast..
if (parent && parent != &valobj) {
ClassDescriptorSP parent_descriptor_sp = GetClassDescriptor(*parent);
if (parent_descriptor_sp)
return parent_descriptor_sp->GetSuperclass();
}
return nullptr;
}
// if we get an invalid VO (which might still happen when playing around
// with pointers returned by the expression parser, don't consider this
// a valid ObjC object)
if (valobj.GetCompilerType().IsValid()) {
addr_t isa_pointer = valobj.GetPointerValue();
// tagged pointer
if (IsTaggedPointer(isa_pointer)) {
return m_tagged_pointer_vendor_ap->GetClassDescriptor(isa_pointer);
} else {
ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
Process *process = exe_ctx.GetProcessPtr();
if (process) {
Error error;
ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
if (isa != LLDB_INVALID_ADDRESS) {
objc_class_sp = GetClassDescriptorFromISA(isa);
if (isa && !objc_class_sp) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log)
log->Printf("0x%" PRIx64
": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
"not in class descriptor cache 0x%" PRIx64,
isa_pointer, isa);
}
}
}
}
}
return objc_class_sp;
}
lldb::addr_t AppleObjCRuntimeV2::GetISAHashTablePointer() {
if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS) {
Process *process = GetProcess();
ModuleSP objc_module_sp(GetObjCModule());
if (!objc_module_sp)
return LLDB_INVALID_ADDRESS;
static ConstString g_gdb_objc_realized_classes("gdb_objc_realized_classes");
const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
g_gdb_objc_realized_classes, lldb::eSymbolTypeAny);
if (symbol) {
lldb::addr_t gdb_objc_realized_classes_ptr =
symbol->GetLoadAddress(&process->GetTarget());
if (gdb_objc_realized_classes_ptr != LLDB_INVALID_ADDRESS) {
Error error;
m_isa_hash_table_ptr = process->ReadPointerFromMemory(
gdb_objc_realized_classes_ptr, error);
}
}
}
return m_isa_hash_table_ptr;
}
AppleObjCRuntimeV2::DescriptorMapUpdateResult
AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic(
RemoteNXMapTable &hash_table) {
Process *process = GetProcess();
if (process == NULL)
return DescriptorMapUpdateResult::Fail();
uint32_t num_class_infos = 0;
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
ExecutionContext exe_ctx;
ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
if (!thread_sp)
return DescriptorMapUpdateResult::Fail();
thread_sp->CalculateExecutionContext(exe_ctx);
ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
if (!ast)
return DescriptorMapUpdateResult::Fail();
Address function_address;
DiagnosticManager diagnostics;
const uint32_t addr_size = process->GetAddressByteSize();
Error err;
// Read the total number of classes from the hash table
const uint32_t num_classes = hash_table.GetCount();
if (num_classes == 0) {
if (log)
log->Printf("No dynamic classes found in gdb_objc_realized_classes.");
return DescriptorMapUpdateResult::Success(0);
}
// Make some types for our arguments
CompilerType clang_uint32_t_type =
ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
CompilerType clang_void_pointer_type =
ast->GetBasicType(eBasicTypeVoid).GetPointerType();
ValueList arguments;
FunctionCaller *get_class_info_function = nullptr;
if (!m_get_class_info_code.get()) {
Error error;
m_get_class_info_code.reset(GetTargetRef().GetUtilityFunctionForLanguage(
g_get_dynamic_class_info_body, eLanguageTypeObjC,
g_get_dynamic_class_info_name, error));
if (error.Fail()) {
if (log)
log->Printf(
"Failed to get Utility Function for implementation lookup: %s",
error.AsCString());
m_get_class_info_code.reset();
} else {
diagnostics.Clear();
if (!m_get_class_info_code->Install(diagnostics, exe_ctx)) {
if (log) {
log->Printf("Failed to install implementation lookup");
diagnostics.Dump(log);
}
m_get_class_info_code.reset();
}
}
if (!m_get_class_info_code.get())
return DescriptorMapUpdateResult::Fail();
// Next make the runner function for our implementation utility function.
Value value;
value.SetValueType(Value::eValueTypeScalar);
value.SetCompilerType(clang_void_pointer_type);
arguments.PushValue(value);
arguments.PushValue(value);
value.SetValueType(Value::eValueTypeScalar);
value.SetCompilerType(clang_uint32_t_type);
arguments.PushValue(value);
arguments.PushValue(value);
get_class_info_function = m_get_class_info_code->MakeFunctionCaller(
clang_uint32_t_type, arguments, thread_sp, error);
if (error.Fail()) {
if (log)
log->Printf(
"Failed to make function caller for implementation lookup: %s.",
error.AsCString());
return DescriptorMapUpdateResult::Fail();
}
} else {
get_class_info_function = m_get_class_info_code->GetFunctionCaller();
if (!get_class_info_function) {
if (log) {
log->Printf("Failed to get implementation lookup function caller.");
diagnostics.Dump(log);
}
return DescriptorMapUpdateResult::Fail();
}
arguments = get_class_info_function->GetArgumentValues();
}
diagnostics.Clear();
const uint32_t class_info_byte_size = addr_size + 4;
const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
lldb::addr_t class_infos_addr = process->AllocateMemory(
class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err);
if (class_infos_addr == LLDB_INVALID_ADDRESS) {
if (log)
log->Printf("unable to allocate %" PRIu32
" bytes in process for shared cache read",
class_infos_byte_size);
return DescriptorMapUpdateResult::Fail();
}
std::lock_guard<std::mutex> guard(m_get_class_info_args_mutex);
// Fill in our function argument values
arguments.GetValueAtIndex(0)->GetScalar() = hash_table.GetTableLoadAddress();
arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
arguments.GetValueAtIndex(3)->GetScalar() =
(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES) == nullptr ? 0 : 1);
bool success = false;
diagnostics.Clear();
// Write our function arguments into the process so we can run our function
if (get_class_info_function->WriteFunctionArguments(
exe_ctx, m_get_class_info_args, arguments, diagnostics)) {
EvaluateExpressionOptions options;
options.SetUnwindOnError(true);
options.SetTryAllThreads(false);
options.SetStopOthers(true);
options.SetIgnoreBreakpoints(true);
options.SetTimeout(g_utility_function_timeout);
Value return_value;
return_value.SetValueType(Value::eValueTypeScalar);
// return_value.SetContext (Value::eContextTypeClangType,
// clang_uint32_t_type);
return_value.SetCompilerType(clang_uint32_t_type);
return_value.GetScalar() = 0;
diagnostics.Clear();
// Run the function
ExpressionResults results = get_class_info_function->ExecuteFunction(
exe_ctx, &m_get_class_info_args, options, diagnostics, return_value);
if (results == eExpressionCompleted) {
// The result is the number of ClassInfo structures that were filled in
num_class_infos = return_value.GetScalar().ULong();
if (log)
log->Printf("Discovered %u ObjC classes\n", num_class_infos);
if (num_class_infos > 0) {
// Read the ClassInfo structures
DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0);
if (process->ReadMemory(class_infos_addr, buffer.GetBytes(),
buffer.GetByteSize(),
err) == buffer.GetByteSize()) {
DataExtractor class_infos_data(buffer.GetBytes(),
buffer.GetByteSize(),
process->GetByteOrder(), addr_size);
ParseClassInfoArray(class_infos_data, num_class_infos);
}
}
success = true;
} else {
if (log) {
log->Printf("Error evaluating our find class name function.");
diagnostics.Dump(log);
}
}
} else {
if (log) {
log->Printf("Error writing function arguments.");
diagnostics.Dump(log);
}
}
// Deallocate the memory we allocated for the ClassInfo array
process->DeallocateMemory(class_infos_addr);
return DescriptorMapUpdateResult(success, num_class_infos);
}
uint32_t AppleObjCRuntimeV2::ParseClassInfoArray(const DataExtractor &data,
uint32_t num_class_infos) {
// Parses an array of "num_class_infos" packed ClassInfo structures:
//
// struct ClassInfo
// {
// Class isa;
// uint32_t hash;
// } __attribute__((__packed__));
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
uint32_t num_parsed = 0;
// Iterate through all ClassInfo structures
lldb::offset_t offset = 0;
for (uint32_t i = 0; i < num_class_infos; ++i) {
ObjCISA isa = data.GetPointer(&offset);
if (isa == 0) {
if (log)
log->Printf(
"AppleObjCRuntimeV2 found NULL isa, ignoring this class info");
continue;
}
// Check if we already know about this ISA, if we do, the info will
// never change, so we can just skip it.
if (ISAIsCached(isa)) {
if (log)
log->Printf("AppleObjCRuntimeV2 found cached isa=0x%" PRIx64
", ignoring this class info",
isa);
offset += 4;
} else {
// Read the 32 bit hash for the class name
const uint32_t name_hash = data.GetU32(&offset);
ClassDescriptorSP descriptor_sp(new ClassDescriptorV2(*this, isa, NULL));
AddClass(isa, descriptor_sp, name_hash);
num_parsed++;
if (log)
log->Printf("AppleObjCRuntimeV2 added isa=0x%" PRIx64
", hash=0x%8.8x, name=%s",
isa, name_hash,
descriptor_sp->GetClassName().AsCString("<unknown>"));
}
}
if (log)
log->Printf("AppleObjCRuntimeV2 parsed %" PRIu32 " class infos",
num_parsed);
return num_parsed;
}
AppleObjCRuntimeV2::DescriptorMapUpdateResult
AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache() {
Process *process = GetProcess();
if (process == NULL)
return DescriptorMapUpdateResult::Fail();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
ExecutionContext exe_ctx;
ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
if (!thread_sp)
return DescriptorMapUpdateResult::Fail();
thread_sp->CalculateExecutionContext(exe_ctx);
ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
if (!ast)
return DescriptorMapUpdateResult::Fail();
Address function_address;
DiagnosticManager diagnostics;
const uint32_t addr_size = process->GetAddressByteSize();
Error err;
uint32_t num_class_infos = 0;
const lldb::addr_t objc_opt_ptr = GetSharedCacheReadOnlyAddress();
if (objc_opt_ptr == LLDB_INVALID_ADDRESS)
return DescriptorMapUpdateResult::Fail();
const uint32_t num_classes = 128 * 1024;
// Make some types for our arguments
CompilerType clang_uint32_t_type =
ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
CompilerType clang_void_pointer_type =
ast->GetBasicType(eBasicTypeVoid).GetPointerType();
ValueList arguments;
FunctionCaller *get_shared_cache_class_info_function = nullptr;
if (!m_get_shared_cache_class_info_code.get()) {
Error error;
m_get_shared_cache_class_info_code.reset(
GetTargetRef().GetUtilityFunctionForLanguage(
g_get_shared_cache_class_info_body, eLanguageTypeObjC,
g_get_shared_cache_class_info_name, error));
if (error.Fail()) {
if (log)
log->Printf(
"Failed to get Utility function for implementation lookup: %s.",
error.AsCString());
m_get_shared_cache_class_info_code.reset();
} else {
diagnostics.Clear();
if (!m_get_shared_cache_class_info_code->Install(diagnostics, exe_ctx)) {
if (log) {
log->Printf("Failed to install implementation lookup.");
diagnostics.Dump(log);
}
m_get_shared_cache_class_info_code.reset();
}
}
if (!m_get_shared_cache_class_info_code.get())
return DescriptorMapUpdateResult::Fail();
// Next make the function caller for our implementation utility function.
Value value;
value.SetValueType(Value::eValueTypeScalar);
// value.SetContext (Value::eContextTypeClangType, clang_void_pointer_type);
value.SetCompilerType(clang_void_pointer_type);
arguments.PushValue(value);
arguments.PushValue(value);
value.SetValueType(Value::eValueTypeScalar);
// value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type);
value.SetCompilerType(clang_uint32_t_type);
arguments.PushValue(value);
arguments.PushValue(value);
get_shared_cache_class_info_function =
m_get_shared_cache_class_info_code->MakeFunctionCaller(
clang_uint32_t_type, arguments, thread_sp, error);
if (get_shared_cache_class_info_function == nullptr)
return DescriptorMapUpdateResult::Fail();
} else {
get_shared_cache_class_info_function =
m_get_shared_cache_class_info_code->GetFunctionCaller();
if (get_shared_cache_class_info_function == nullptr)
return DescriptorMapUpdateResult::Fail();
arguments = get_shared_cache_class_info_function->GetArgumentValues();
}
diagnostics.Clear();
const uint32_t class_info_byte_size = addr_size + 4;
const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
lldb::addr_t class_infos_addr = process->AllocateMemory(
class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err);
if (class_infos_addr == LLDB_INVALID_ADDRESS) {
if (log)
log->Printf("unable to allocate %" PRIu32
" bytes in process for shared cache read",
class_infos_byte_size);
return DescriptorMapUpdateResult::Fail();
}
std::lock_guard<std::mutex> guard(m_get_shared_cache_class_info_args_mutex);
// Fill in our function argument values
arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr;
arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
arguments.GetValueAtIndex(3)->GetScalar() =
(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES) == nullptr ? 0 : 1);
bool success = false;
diagnostics.Clear();
// Write our function arguments into the process so we can run our function
if (get_shared_cache_class_info_function->WriteFunctionArguments(
exe_ctx, m_get_shared_cache_class_info_args, arguments,
diagnostics)) {
EvaluateExpressionOptions options;
options.SetUnwindOnError(true);
options.SetTryAllThreads(false);
options.SetStopOthers(true);
options.SetIgnoreBreakpoints(true);
options.SetTimeout(g_utility_function_timeout);
Value return_value;
return_value.SetValueType(Value::eValueTypeScalar);
// return_value.SetContext (Value::eContextTypeClangType,
// clang_uint32_t_type);
return_value.SetCompilerType(clang_uint32_t_type);
return_value.GetScalar() = 0;
diagnostics.Clear();
// Run the function
ExpressionResults results =
get_shared_cache_class_info_function->ExecuteFunction(
exe_ctx, &m_get_shared_cache_class_info_args, options, diagnostics,
return_value);
if (results == eExpressionCompleted) {
// The result is the number of ClassInfo structures that were filled in
num_class_infos = return_value.GetScalar().ULong();
if (log)
log->Printf("Discovered %u ObjC classes in shared cache\n",
num_class_infos);
#ifdef LLDB_CONFIGURATION_DEBUG
assert(num_class_infos <= num_classes);
#endif
if (num_class_infos > 0) {
if (num_class_infos > num_classes) {
num_class_infos = num_classes;
success = false;
} else {
success = true;
}
// Read the ClassInfo structures
DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0);
if (process->ReadMemory(class_infos_addr, buffer.GetBytes(),
buffer.GetByteSize(),
err) == buffer.GetByteSize()) {
DataExtractor class_infos_data(buffer.GetBytes(),
buffer.GetByteSize(),
process->GetByteOrder(), addr_size);
ParseClassInfoArray(class_infos_data, num_class_infos);
}
} else {
success = true;
}
} else {
if (log) {
log->Printf("Error evaluating our find class name function.");
diagnostics.Dump(log);
}
}
} else {
if (log) {
log->Printf("Error writing function arguments.");
diagnostics.Dump(log);
}
}
// Deallocate the memory we allocated for the ClassInfo array
process->DeallocateMemory(class_infos_addr);
return DescriptorMapUpdateResult(success, num_class_infos);
}
bool AppleObjCRuntimeV2::UpdateISAToDescriptorMapFromMemory(
RemoteNXMapTable &hash_table) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
Process *process = GetProcess();
if (process == NULL)
return false;
uint32_t num_map_table_isas = 0;
ModuleSP objc_module_sp(GetObjCModule());
if (objc_module_sp) {
for (RemoteNXMapTable::element elt : hash_table) {
++num_map_table_isas;
if (ISAIsCached(elt.second))
continue;
ClassDescriptorSP descriptor_sp = ClassDescriptorSP(
new ClassDescriptorV2(*this, elt.second, elt.first.AsCString()));
if (log && log->GetVerbose())
log->Printf("AppleObjCRuntimeV2 added (ObjCISA)0x%" PRIx64
" (%s) from dynamic table to isa->descriptor cache",
elt.second, elt.first.AsCString());
AddClass(elt.second, descriptor_sp, elt.first.AsCString());
}
}
return num_map_table_isas > 0;
}
lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress() {
Process *process = GetProcess();
if (process) {
ModuleSP objc_module_sp(GetObjCModule());
if (objc_module_sp) {
ObjectFile *objc_object = objc_module_sp->GetObjectFile();
if (objc_object) {
SectionList *section_list = objc_module_sp->GetSectionList();
if (section_list) {
SectionSP text_segment_sp(
section_list->FindSectionByName(ConstString("__TEXT")));
if (text_segment_sp) {
SectionSP objc_opt_section_sp(
text_segment_sp->GetChildren().FindSectionByName(
ConstString("__objc_opt_ro")));
if (objc_opt_section_sp) {
return objc_opt_section_sp->GetLoadBaseAddress(
&process->GetTarget());
}
}
}
}
}
}
return LLDB_INVALID_ADDRESS;
}
void AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded() {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
// Else we need to check with our process to see when the map was updated.
Process *process = GetProcess();
if (process) {
RemoteNXMapTable hash_table;
// Update the process stop ID that indicates the last time we updated the
// map, whether it was successful or not.
m_isa_to_descriptor_stop_id = process->GetStopID();
if (!m_hash_signature.NeedsUpdate(process, this, hash_table))
return;
m_hash_signature.UpdateSignature(hash_table);
// Grab the dynamically loaded objc classes from the hash table in memory
DescriptorMapUpdateResult dynamic_update_result =
UpdateISAToDescriptorMapDynamic(hash_table);
// Now get the objc classes that are baked into the Objective C runtime
// in the shared cache, but only once per process as this data never
// changes
if (!m_loaded_objc_opt) {
// it is legitimately possible for the shared cache to be empty - in that
// case, the dynamic hash table
// will contain all the class information we need; the situation we're
// trying to detect is one where
// we aren't seeing class information from the runtime - in order to
// detect that vs. just the shared cache
// being empty or sparsely populated, we set an arbitrary (very low)
// threshold for the number of classes
// that we want to see in a "good" scenario - anything below that is
// suspicious (Foundation alone has thousands
// of classes)
const uint32_t num_classes_to_warn_at = 500;
DescriptorMapUpdateResult shared_cache_update_result =
UpdateISAToDescriptorMapSharedCache();
if (log)
log->Printf("attempted to read objc class data - results: "
"[dynamic_update]: ran: %s, count: %" PRIu32
" [shared_cache_update]: ran: %s, count: %" PRIu32,
dynamic_update_result.m_update_ran ? "yes" : "no",
dynamic_update_result.m_num_found,
shared_cache_update_result.m_update_ran ? "yes" : "no",
shared_cache_update_result.m_num_found);
// warn if:
// - we could not run either expression
// - we found fewer than num_classes_to_warn_at classes total
if ((false == shared_cache_update_result.m_update_ran) ||
(false == dynamic_update_result.m_update_ran))
WarnIfNoClassesCached(
SharedCacheWarningReason::eExpressionExecutionFailure);
else if (dynamic_update_result.m_num_found +
shared_cache_update_result.m_num_found <
num_classes_to_warn_at)
WarnIfNoClassesCached(SharedCacheWarningReason::eNotEnoughClassesRead);
else
m_loaded_objc_opt = true;
}
} else {
m_isa_to_descriptor_stop_id = UINT32_MAX;
}
}
static bool DoesProcessHaveSharedCache(Process &process) {
PlatformSP platform_sp = process.GetTarget().GetPlatform();
if (!platform_sp)
return true; // this should not happen
ConstString platform_plugin_name = platform_sp->GetPluginName();
if (platform_plugin_name) {
llvm::StringRef platform_plugin_name_sr =
platform_plugin_name.GetStringRef();
if (platform_plugin_name_sr.endswith("-simulator"))
return false;
}
return true;
}
void AppleObjCRuntimeV2::WarnIfNoClassesCached(
SharedCacheWarningReason reason) {
if (m_noclasses_warning_emitted)
return;
if (GetProcess() && !DoesProcessHaveSharedCache(*GetProcess())) {
// Simulators do not have the objc_opt_ro class table so don't actually
// complain to the user
m_noclasses_warning_emitted = true;
return;
}
Debugger &debugger(GetProcess()->GetTarget().GetDebugger());
if (auto stream = debugger.GetAsyncOutputStream()) {
switch (reason) {
case SharedCacheWarningReason::eNotEnoughClassesRead:
stream->PutCString("warning: could not find Objective-C class data in "
"the process. This may reduce the quality of type "
"information available.\n");
m_noclasses_warning_emitted = true;
break;
case SharedCacheWarningReason::eExpressionExecutionFailure:
stream->PutCString("warning: could not execute support code to read "
"Objective-C class data in the process. This may "
"reduce the quality of type information available.\n");
m_noclasses_warning_emitted = true;
break;
}
}
}
ConstString
AppleObjCRuntimeV2::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) {
if (isa == g_objc_Tagged_ISA) {
static const ConstString g_objc_tagged_isa_name("_lldb_Tagged_ObjC_ISA");
return g_objc_tagged_isa_name;
}
if (isa == g_objc_Tagged_ISA_NSAtom) {
static const ConstString g_objc_tagged_isa_nsatom_name("NSAtom");
return g_objc_tagged_isa_nsatom_name;
}
if (isa == g_objc_Tagged_ISA_NSNumber) {
static const ConstString g_objc_tagged_isa_nsnumber_name("NSNumber");
return g_objc_tagged_isa_nsnumber_name;
}
if (isa == g_objc_Tagged_ISA_NSDateTS) {
static const ConstString g_objc_tagged_isa_nsdatets_name("NSDateTS");
return g_objc_tagged_isa_nsdatets_name;
}
if (isa == g_objc_Tagged_ISA_NSManagedObject) {
static const ConstString g_objc_tagged_isa_nsmanagedobject_name(
"NSManagedObject");
return g_objc_tagged_isa_nsmanagedobject_name;
}
if (isa == g_objc_Tagged_ISA_NSDate) {
static const ConstString g_objc_tagged_isa_nsdate_name("NSDate");
return g_objc_tagged_isa_nsdate_name;
}
return ObjCLanguageRuntime::GetActualTypeName(isa);
}
DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() {
if (!m_decl_vendor_ap.get())
m_decl_vendor_ap.reset(new AppleObjCDeclVendor(*this));
return m_decl_vendor_ap.get();
}
lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(const ConstString &name) {
lldb::addr_t ret = LLDB_INVALID_ADDRESS;
const char *name_cstr = name.AsCString();
if (name_cstr) {
llvm::StringRef name_strref(name_cstr);
static const llvm::StringRef ivar_prefix("OBJC_IVAR_$_");
static const llvm::StringRef class_prefix("OBJC_CLASS_$_");
if (name_strref.startswith(ivar_prefix)) {
llvm::StringRef ivar_skipped_prefix =
name_strref.substr(ivar_prefix.size());
std::pair<llvm::StringRef, llvm::StringRef> class_and_ivar =
ivar_skipped_prefix.split('.');
if (class_and_ivar.first.size() && class_and_ivar.second.size()) {
const ConstString class_name_cs(class_and_ivar.first);
ClassDescriptorSP descriptor =
ObjCLanguageRuntime::GetClassDescriptorFromClassName(class_name_cs);
if (descriptor) {
const ConstString ivar_name_cs(class_and_ivar.second);
const char *ivar_name_cstr = ivar_name_cs.AsCString();
auto ivar_func = [&ret, ivar_name_cstr](
const char *name, const char *type, lldb::addr_t offset_addr,
uint64_t size) -> lldb::addr_t {
if (!strcmp(name, ivar_name_cstr)) {
ret = offset_addr;
return true;
}
return false;
};
descriptor->Describe(
std::function<void(ObjCISA)>(nullptr),
std::function<bool(const char *, const char *)>(nullptr),
std::function<bool(const char *, const char *)>(nullptr),
ivar_func);
}
}
} else if (name_strref.startswith(class_prefix)) {
llvm::StringRef class_skipped_prefix =
name_strref.substr(class_prefix.size());
const ConstString class_name_cs(class_skipped_prefix);
ClassDescriptorSP descriptor =
GetClassDescriptorFromClassName(class_name_cs);
if (descriptor)
ret = descriptor->GetISA();
}
}
return ret;
}
AppleObjCRuntimeV2::NonPointerISACache *
AppleObjCRuntimeV2::NonPointerISACache::CreateInstance(
AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) {
Process *process(runtime.GetProcess());
Error error;
auto objc_debug_isa_magic_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_isa_magic_mask"), objc_module_sp, error);
if (error.Fail())
return NULL;
auto objc_debug_isa_magic_value = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_isa_magic_value"), objc_module_sp,
error);
if (error.Fail())
return NULL;
auto objc_debug_isa_class_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_isa_class_mask"), objc_module_sp, error);
if (error.Fail())
return NULL;
// we might want to have some rules to outlaw these other values (e.g if the
// mask is zero but the value is non-zero, ...)
return new NonPointerISACache(runtime, objc_debug_isa_class_mask,
objc_debug_isa_magic_mask,
objc_debug_isa_magic_value);
}
AppleObjCRuntimeV2::TaggedPointerVendorV2 *
AppleObjCRuntimeV2::TaggedPointerVendorV2::CreateInstance(
AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) {
Process *process(runtime.GetProcess());
Error error;
auto objc_debug_taggedpointer_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_mask"), objc_module_sp,
error);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_slot_shift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_slot_shift"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_slot_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_slot_mask"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_payload_lshift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_payload_lshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_payload_rshift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_payload_rshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_classes = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_classes"), objc_module_sp,
error, false);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
// try to detect the "extended tagged pointer" variables - if any are missing,
// use the non-extended vendor
do {
auto objc_debug_taggedpointer_ext_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_mask"),
objc_module_sp, error);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_slot_shift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_slot_shift"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_slot_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_slot_mask"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_classes = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_classes"),
objc_module_sp, error, false);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_payload_lshift =
ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_payload_lshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_payload_rshift =
ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_payload_rshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
return new TaggedPointerVendorExtended(
runtime, objc_debug_taggedpointer_mask,
objc_debug_taggedpointer_ext_mask, objc_debug_taggedpointer_slot_shift,
objc_debug_taggedpointer_ext_slot_shift,
objc_debug_taggedpointer_slot_mask,
objc_debug_taggedpointer_ext_slot_mask,
objc_debug_taggedpointer_payload_lshift,
objc_debug_taggedpointer_payload_rshift,
objc_debug_taggedpointer_ext_payload_lshift,
objc_debug_taggedpointer_ext_payload_rshift,
objc_debug_taggedpointer_classes, objc_debug_taggedpointer_ext_classes);
} while (false);
// we might want to have some rules to outlaw these values (e.g if the table's
// address is zero)
return new TaggedPointerVendorRuntimeAssisted(
runtime, objc_debug_taggedpointer_mask,
objc_debug_taggedpointer_slot_shift, objc_debug_taggedpointer_slot_mask,
objc_debug_taggedpointer_payload_lshift,
objc_debug_taggedpointer_payload_rshift,
objc_debug_taggedpointer_classes);
}
bool AppleObjCRuntimeV2::TaggedPointerVendorLegacy::IsPossibleTaggedPointer(
lldb::addr_t ptr) {
return (ptr & 1);
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::TaggedPointerVendorLegacy::GetClassDescriptor(
lldb::addr_t ptr) {
if (!IsPossibleTaggedPointer(ptr))
return ObjCLanguageRuntime::ClassDescriptorSP();
uint32_t foundation_version = m_runtime.GetFoundationVersion();
if (foundation_version == LLDB_INVALID_MODULE_VERSION)
return ObjCLanguageRuntime::ClassDescriptorSP();
uint64_t class_bits = (ptr & 0xE) >> 1;
ConstString name;
static ConstString g_NSAtom("NSAtom");
static ConstString g_NSNumber("NSNumber");
static ConstString g_NSDateTS("NSDateTS");
static ConstString g_NSManagedObject("NSManagedObject");
static ConstString g_NSDate("NSDate");
if (foundation_version >= 900) {
switch (class_bits) {
case 0:
name = g_NSAtom;
break;
case 3:
name = g_NSNumber;
break;
case 4:
name = g_NSDateTS;
break;
case 5:
name = g_NSManagedObject;
break;
case 6:
name = g_NSDate;
break;
default:
return ObjCLanguageRuntime::ClassDescriptorSP();
}
} else {
switch (class_bits) {
case 1:
name = g_NSNumber;
break;
case 5:
name = g_NSManagedObject;
break;
case 6:
name = g_NSDate;
break;
case 7:
name = g_NSDateTS;
break;
default:
return ObjCLanguageRuntime::ClassDescriptorSP();
}
}
return ClassDescriptorSP(new ClassDescriptorV2Tagged(name, ptr));
}
AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::
TaggedPointerVendorRuntimeAssisted(
AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
uint32_t objc_debug_taggedpointer_slot_shift,
uint32_t objc_debug_taggedpointer_slot_mask,
uint32_t objc_debug_taggedpointer_payload_lshift,
uint32_t objc_debug_taggedpointer_payload_rshift,
lldb::addr_t objc_debug_taggedpointer_classes)
: TaggedPointerVendorV2(runtime), m_cache(),
m_objc_debug_taggedpointer_mask(objc_debug_taggedpointer_mask),
m_objc_debug_taggedpointer_slot_shift(
objc_debug_taggedpointer_slot_shift),
m_objc_debug_taggedpointer_slot_mask(objc_debug_taggedpointer_slot_mask),
m_objc_debug_taggedpointer_payload_lshift(
objc_debug_taggedpointer_payload_lshift),
m_objc_debug_taggedpointer_payload_rshift(
objc_debug_taggedpointer_payload_rshift),
m_objc_debug_taggedpointer_classes(objc_debug_taggedpointer_classes) {}
bool AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::
IsPossibleTaggedPointer(lldb::addr_t ptr) {
return (ptr & m_objc_debug_taggedpointer_mask) != 0;
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(
lldb::addr_t ptr) {
ClassDescriptorSP actual_class_descriptor_sp;
uint64_t data_payload;
if (!IsPossibleTaggedPointer(ptr))
return ObjCLanguageRuntime::ClassDescriptorSP();
uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_slot_shift) &
m_objc_debug_taggedpointer_slot_mask;
CacheIterator iterator = m_cache.find(slot), end = m_cache.end();
if (iterator != end) {
actual_class_descriptor_sp = iterator->second;
} else {
Process *process(m_runtime.GetProcess());
uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
m_objc_debug_taggedpointer_classes;
Error error;
uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
if (error.Fail() || slot_data == 0 ||
slot_data == uintptr_t(LLDB_INVALID_ADDRESS))
return nullptr;
actual_class_descriptor_sp =
m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
if (!actual_class_descriptor_sp)
return ObjCLanguageRuntime::ClassDescriptorSP();
m_cache[slot] = actual_class_descriptor_sp;
}
data_payload =
(((uint64_t)ptr << m_objc_debug_taggedpointer_payload_lshift) >>
m_objc_debug_taggedpointer_payload_rshift);
return ClassDescriptorSP(
new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload));
}
AppleObjCRuntimeV2::TaggedPointerVendorExtended::TaggedPointerVendorExtended(
AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
uint64_t objc_debug_taggedpointer_ext_mask,
uint32_t objc_debug_taggedpointer_slot_shift,
uint32_t objc_debug_taggedpointer_ext_slot_shift,
uint32_t objc_debug_taggedpointer_slot_mask,
uint32_t objc_debug_taggedpointer_ext_slot_mask,
uint32_t objc_debug_taggedpointer_payload_lshift,
uint32_t objc_debug_taggedpointer_payload_rshift,
uint32_t objc_debug_taggedpointer_ext_payload_lshift,
uint32_t objc_debug_taggedpointer_ext_payload_rshift,
lldb::addr_t objc_debug_taggedpointer_classes,
lldb::addr_t objc_debug_taggedpointer_ext_classes)
: TaggedPointerVendorRuntimeAssisted(
runtime, objc_debug_taggedpointer_mask,
objc_debug_taggedpointer_slot_shift,
objc_debug_taggedpointer_slot_mask,
objc_debug_taggedpointer_payload_lshift,
objc_debug_taggedpointer_payload_rshift,
objc_debug_taggedpointer_classes),
m_ext_cache(),
m_objc_debug_taggedpointer_ext_mask(objc_debug_taggedpointer_ext_mask),
m_objc_debug_taggedpointer_ext_slot_shift(
objc_debug_taggedpointer_ext_slot_shift),
m_objc_debug_taggedpointer_ext_slot_mask(
objc_debug_taggedpointer_ext_slot_mask),
m_objc_debug_taggedpointer_ext_payload_lshift(
objc_debug_taggedpointer_ext_payload_lshift),
m_objc_debug_taggedpointer_ext_payload_rshift(
objc_debug_taggedpointer_ext_payload_rshift),
m_objc_debug_taggedpointer_ext_classes(
objc_debug_taggedpointer_ext_classes) {}
bool AppleObjCRuntimeV2::TaggedPointerVendorExtended::
IsPossibleExtendedTaggedPointer(lldb::addr_t ptr) {
if (!IsPossibleTaggedPointer(ptr))
return false;
if (m_objc_debug_taggedpointer_ext_mask == 0)
return false;
return ((ptr & m_objc_debug_taggedpointer_ext_mask) ==
m_objc_debug_taggedpointer_ext_mask);
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::TaggedPointerVendorExtended::GetClassDescriptor(
lldb::addr_t ptr) {
ClassDescriptorSP actual_class_descriptor_sp;
uint64_t data_payload;
if (!IsPossibleTaggedPointer(ptr))
return ObjCLanguageRuntime::ClassDescriptorSP();
if (!IsPossibleExtendedTaggedPointer(ptr))
return this->TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(ptr);
uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_ext_slot_shift) &
m_objc_debug_taggedpointer_ext_slot_mask;
CacheIterator iterator = m_ext_cache.find(slot), end = m_ext_cache.end();
if (iterator != end) {
actual_class_descriptor_sp = iterator->second;
} else {
Process *process(m_runtime.GetProcess());
uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
m_objc_debug_taggedpointer_ext_classes;
Error error;
uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
if (error.Fail() || slot_data == 0 ||
slot_data == uintptr_t(LLDB_INVALID_ADDRESS))
return nullptr;
actual_class_descriptor_sp =
m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
if (!actual_class_descriptor_sp)
return ObjCLanguageRuntime::ClassDescriptorSP();
m_ext_cache[slot] = actual_class_descriptor_sp;
}
data_payload =
(((uint64_t)ptr << m_objc_debug_taggedpointer_ext_payload_lshift) >>
m_objc_debug_taggedpointer_ext_payload_rshift);
return ClassDescriptorSP(
new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload));
}
AppleObjCRuntimeV2::NonPointerISACache::NonPointerISACache(
AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_isa_class_mask,
uint64_t objc_debug_isa_magic_mask, uint64_t objc_debug_isa_magic_value)
: m_runtime(runtime), m_cache(),
m_objc_debug_isa_class_mask(objc_debug_isa_class_mask),
m_objc_debug_isa_magic_mask(objc_debug_isa_magic_mask),
m_objc_debug_isa_magic_value(objc_debug_isa_magic_value) {}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor(ObjCISA isa) {
ObjCISA real_isa = 0;
if (EvaluateNonPointerISA(isa, real_isa) == false)
return ObjCLanguageRuntime::ClassDescriptorSP();
auto cache_iter = m_cache.find(real_isa);
if (cache_iter != m_cache.end())
return cache_iter->second;
auto descriptor_sp =
m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(real_isa);
if (descriptor_sp) // cache only positive matches since the table might grow
m_cache[real_isa] = descriptor_sp;
return descriptor_sp;
}
bool AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(
ObjCISA isa, ObjCISA &ret_isa) {
if ((isa & ~m_objc_debug_isa_class_mask) == 0)
return false;
if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) {
ret_isa = isa & m_objc_debug_isa_class_mask;
return (ret_isa != 0); // this is a pointer so 0 is not a valid value
}
return false;
}
ObjCLanguageRuntime::EncodingToTypeSP AppleObjCRuntimeV2::GetEncodingToType() {
if (!m_encoding_to_type_sp)
m_encoding_to_type_sp.reset(new AppleObjCTypeEncodingParser(*this));
return m_encoding_to_type_sp;
}
lldb_private::AppleObjCRuntime::ObjCISA
AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) {
ObjCISA ret = isa;
if (m_non_pointer_isa_cache_ap)
m_non_pointer_isa_cache_ap->EvaluateNonPointerISA(isa, ret);
return ret;
}
bool AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded() {
if (m_CFBoolean_values)
return true;
static ConstString g_kCFBooleanFalse("kCFBooleanFalse");
static ConstString g_kCFBooleanTrue("kCFBooleanTrue");
std::function<lldb::addr_t(ConstString)> get_symbol =
[this](ConstString sym) -> lldb::addr_t {
SymbolContextList sc_list;
if (GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
g_kCFBooleanFalse, lldb::eSymbolTypeData, sc_list) == 1) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
if (sc.symbol)
return sc.symbol->GetLoadAddress(&GetProcess()->GetTarget());
}
return LLDB_INVALID_ADDRESS;
};
lldb::addr_t false_addr = get_symbol(g_kCFBooleanFalse);
lldb::addr_t true_addr = get_symbol(g_kCFBooleanTrue);
return (m_CFBoolean_values = {false_addr, true_addr}).operator bool();
}
void AppleObjCRuntimeV2::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
lldb::addr_t &cf_false) {
if (GetCFBooleanValuesIfNeeded()) {
cf_true = m_CFBoolean_values->second;
cf_false = m_CFBoolean_values->first;
} else
this->AppleObjCRuntime::GetValuesForGlobalCFBooleans(cf_true, cf_false);
}
Tone down the "lldb types" log a bit.
Change the get shared class info function to only
dump its results to the inferior stdout when the
log is verbose. This matches the lldb side of the
same process, which only logs what it found if the
log is on verbose.
git-svn-id: 4c4cc70b1ef44ba2b7963015e681894188cea27e@299451 91177308-0d34-0410-b5e6-96231b3b80d8
//===-- AppleObjCRuntimeV2.cpp ----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
#include <stdint.h>
// C++ Includes
#include <string>
#include <vector>
// Other libraries and framework includes
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
// Project includes
#include "lldb/Core/ClangForward.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/Core/ClangForward.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/Timer.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Expression/DiagnosticManager.h"
#include "lldb/Expression/FunctionCaller.h"
#include "lldb/Expression/UtilityFunction.h"
#include "lldb/Host/StringConvert.h"
#include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandObjectMultiword.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/OptionValueBoolean.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "AppleObjCClassDescriptorV2.h"
#include "AppleObjCDeclVendor.h"
#include "AppleObjCRuntimeV2.h"
#include "AppleObjCTrampolineHandler.h"
#include "AppleObjCTypeEncodingParser.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
#include <vector>
using namespace lldb;
using namespace lldb_private;
// 2 second timeout when running utility functions
static constexpr std::chrono::seconds g_utility_function_timeout(2);
static const char *g_get_dynamic_class_info_name =
"__lldb_apple_objc_v2_get_dynamic_class_info";
// Testing using the new C++11 raw string literals. If this breaks GCC then we
// will
// need to revert to the code above...
static const char *g_get_dynamic_class_info_body = R"(
extern "C"
{
size_t strlen(const char *);
char *strncpy (char * s1, const char * s2, size_t n);
int printf(const char * format, ...);
}
#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)
typedef struct _NXMapTable {
void *prototype;
unsigned num_classes;
unsigned num_buckets_minus_one;
void *buckets;
} NXMapTable;
#define NX_MAPNOTAKEY ((void *)(-1))
typedef struct BucketInfo
{
const char *name_ptr;
Class isa;
} BucketInfo;
struct ClassInfo
{
Class isa;
uint32_t hash;
} __attribute__((__packed__));
uint32_t
__lldb_apple_objc_v2_get_dynamic_class_info (void *gdb_objc_realized_classes_ptr,
void *class_infos_ptr,
uint32_t class_infos_byte_size,
uint32_t should_log)
{
DEBUG_PRINTF ("gdb_objc_realized_classes_ptr = %p\n", gdb_objc_realized_classes_ptr);
DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
DEBUG_PRINTF ("class_infos_byte_size = %u\n", class_infos_byte_size);
const NXMapTable *grc = (const NXMapTable *)gdb_objc_realized_classes_ptr;
if (grc)
{
const unsigned num_classes = grc->num_classes;
if (class_infos_ptr)
{
const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
BucketInfo *buckets = (BucketInfo *)grc->buckets;
uint32_t idx = 0;
for (unsigned i=0; i<=grc->num_buckets_minus_one; ++i)
{
if (buckets[i].name_ptr != NX_MAPNOTAKEY)
{
if (idx < max_class_infos)
{
const char *s = buckets[i].name_ptr;
uint32_t h = 5381;
for (unsigned char c = *s; c; c = *++s)
h = ((h << 5) + h) + c;
class_infos[idx].hash = h;
class_infos[idx].isa = buckets[i].isa;
}
++idx;
}
}
if (idx < max_class_infos)
{
class_infos[idx].isa = NULL;
class_infos[idx].hash = 0;
}
}
return num_classes;
}
return 0;
}
)";
static const char *g_get_shared_cache_class_info_name =
"__lldb_apple_objc_v2_get_shared_cache_class_info";
// Testing using the new C++11 raw string literals. If this breaks GCC then we
// will
// need to revert to the code above...
static const char *g_get_shared_cache_class_info_body = R"(
extern "C"
{
const char *class_getName(void *objc_class);
size_t strlen(const char *);
char *strncpy (char * s1, const char * s2, size_t n);
int printf(const char * format, ...);
}
#define DEBUG_PRINTF(fmt, ...) if (should_log) printf(fmt, ## __VA_ARGS__)
struct objc_classheader_t {
int32_t clsOffset;
int32_t hiOffset;
};
struct objc_clsopt_t {
uint32_t capacity;
uint32_t occupied;
uint32_t shift;
uint32_t mask;
uint32_t zero;
uint32_t unused;
uint64_t salt;
uint32_t scramble[256];
uint8_t tab[0]; // tab[mask+1]
// uint8_t checkbytes[capacity];
// int32_t offset[capacity];
// objc_classheader_t clsOffsets[capacity];
// uint32_t duplicateCount;
// objc_classheader_t duplicateOffsets[duplicateCount];
};
struct objc_opt_t {
uint32_t version;
int32_t selopt_offset;
int32_t headeropt_offset;
int32_t clsopt_offset;
};
struct objc_opt_v14_t {
uint32_t version;
uint32_t flags;
int32_t selopt_offset;
int32_t headeropt_offset;
int32_t clsopt_offset;
};
struct ClassInfo
{
Class isa;
uint32_t hash;
} __attribute__((__packed__));
uint32_t
__lldb_apple_objc_v2_get_shared_cache_class_info (void *objc_opt_ro_ptr,
void *class_infos_ptr,
uint32_t class_infos_byte_size,
uint32_t should_log)
{
uint32_t idx = 0;
DEBUG_PRINTF ("objc_opt_ro_ptr = %p\n", objc_opt_ro_ptr);
DEBUG_PRINTF ("class_infos_ptr = %p\n", class_infos_ptr);
DEBUG_PRINTF ("class_infos_byte_size = %u (%llu class infos)\n", class_infos_byte_size, (uint64_t)(class_infos_byte_size/sizeof(ClassInfo)));
if (objc_opt_ro_ptr)
{
const objc_opt_t *objc_opt = (objc_opt_t *)objc_opt_ro_ptr;
const objc_opt_v14_t* objc_opt_v14 = (objc_opt_v14_t*)objc_opt_ro_ptr;
const bool is_v14_format = objc_opt->version >= 14;
if (is_v14_format)
{
DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt_v14->version);
DEBUG_PRINTF ("objc_opt->flags = %u\n", objc_opt_v14->flags);
DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt_v14->selopt_offset);
DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt_v14->headeropt_offset);
DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt_v14->clsopt_offset);
}
else
{
DEBUG_PRINTF ("objc_opt->version = %u\n", objc_opt->version);
DEBUG_PRINTF ("objc_opt->selopt_offset = %d\n", objc_opt->selopt_offset);
DEBUG_PRINTF ("objc_opt->headeropt_offset = %d\n", objc_opt->headeropt_offset);
DEBUG_PRINTF ("objc_opt->clsopt_offset = %d\n", objc_opt->clsopt_offset);
}
if (objc_opt->version == 12 || objc_opt->version == 13 || objc_opt->version == 14 || objc_opt->version == 15)
{
const objc_clsopt_t* clsopt = NULL;
if (is_v14_format)
clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt_v14 + objc_opt_v14->clsopt_offset);
else
clsopt = (const objc_clsopt_t*)((uint8_t *)objc_opt + objc_opt->clsopt_offset);
const size_t max_class_infos = class_infos_byte_size/sizeof(ClassInfo);
DEBUG_PRINTF("max_class_infos = %llu\n", (uint64_t)max_class_infos);
ClassInfo *class_infos = (ClassInfo *)class_infos_ptr;
int32_t invalidEntryOffset = 0;
// this is safe to do because the version field order is invariant
if (objc_opt->version == 12)
invalidEntryOffset = 16;
const uint8_t *checkbytes = &clsopt->tab[clsopt->mask+1];
const int32_t *offsets = (const int32_t *)(checkbytes + clsopt->capacity);
const objc_classheader_t *classOffsets = (const objc_classheader_t *)(offsets + clsopt->capacity);
DEBUG_PRINTF ("clsopt->capacity = %u\n", clsopt->capacity);
DEBUG_PRINTF ("clsopt->mask = 0x%8.8x\n", clsopt->mask);
DEBUG_PRINTF ("classOffsets = %p\n", classOffsets);
DEBUG_PRINTF("invalidEntryOffset = %d\n", invalidEntryOffset);
for (uint32_t i=0; i<clsopt->capacity; ++i)
{
const int32_t clsOffset = classOffsets[i].clsOffset;
DEBUG_PRINTF("clsOffset[%u] = %u\n", i, clsOffset);
if (clsOffset & 1)
{
DEBUG_PRINTF("clsOffset & 1\n");
continue; // duplicate
}
else if (clsOffset == invalidEntryOffset)
{
DEBUG_PRINTF("clsOffset == invalidEntryOffset\n");
continue; // invalid offset
}
if (class_infos && idx < max_class_infos)
{
class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
const char *name = class_getName (class_infos[idx].isa);
DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
// Hash the class name so we don't have to read it
const char *s = name;
uint32_t h = 5381;
for (unsigned char c = *s; c; c = *++s)
h = ((h << 5) + h) + c;
class_infos[idx].hash = h;
}
else
{
DEBUG_PRINTF("not(class_infos && idx < max_class_infos)\n");
}
++idx;
}
const uint32_t *duplicate_count_ptr = (uint32_t *)&classOffsets[clsopt->capacity];
const uint32_t duplicate_count = *duplicate_count_ptr;
const objc_classheader_t *duplicateClassOffsets = (const objc_classheader_t *)(&duplicate_count_ptr[1]);
DEBUG_PRINTF ("duplicate_count = %u\n", duplicate_count);
DEBUG_PRINTF ("duplicateClassOffsets = %p\n", duplicateClassOffsets);
for (uint32_t i=0; i<duplicate_count; ++i)
{
const int32_t clsOffset = duplicateClassOffsets[i].clsOffset;
if (clsOffset & 1)
continue; // duplicate
else if (clsOffset == invalidEntryOffset)
continue; // invalid offset
if (class_infos && idx < max_class_infos)
{
class_infos[idx].isa = (Class)((uint8_t *)clsopt + clsOffset);
const char *name = class_getName (class_infos[idx].isa);
DEBUG_PRINTF ("[%u] isa = %8p %s\n", idx, class_infos[idx].isa, name);
// Hash the class name so we don't have to read it
const char *s = name;
uint32_t h = 5381;
for (unsigned char c = *s; c; c = *++s)
h = ((h << 5) + h) + c;
class_infos[idx].hash = h;
}
++idx;
}
}
DEBUG_PRINTF ("%u class_infos\n", idx);
DEBUG_PRINTF ("done\n");
}
return idx;
}
)";
static uint64_t
ExtractRuntimeGlobalSymbol(Process *process, ConstString name,
const ModuleSP &module_sp, Error &error,
bool read_value = true, uint8_t byte_size = 0,
uint64_t default_value = LLDB_INVALID_ADDRESS,
SymbolType sym_type = lldb::eSymbolTypeData) {
if (!process) {
error.SetErrorString("no process");
return default_value;
}
if (!module_sp) {
error.SetErrorString("no module");
return default_value;
}
if (!byte_size)
byte_size = process->GetAddressByteSize();
const Symbol *symbol =
module_sp->FindFirstSymbolWithNameAndType(name, lldb::eSymbolTypeData);
if (symbol && symbol->ValueIsAddress()) {
lldb::addr_t symbol_load_addr =
symbol->GetAddressRef().GetLoadAddress(&process->GetTarget());
if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
if (read_value)
return process->ReadUnsignedIntegerFromMemory(
symbol_load_addr, byte_size, default_value, error);
else
return symbol_load_addr;
} else {
error.SetErrorString("symbol address invalid");
return default_value;
}
} else {
error.SetErrorString("no symbol");
return default_value;
}
}
AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process,
const ModuleSP &objc_module_sp)
: AppleObjCRuntime(process), m_get_class_info_code(),
m_get_class_info_args(LLDB_INVALID_ADDRESS),
m_get_class_info_args_mutex(), m_get_shared_cache_class_info_code(),
m_get_shared_cache_class_info_args(LLDB_INVALID_ADDRESS),
m_get_shared_cache_class_info_args_mutex(), m_decl_vendor_ap(),
m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS), m_hash_signature(),
m_has_object_getClass(false), m_loaded_objc_opt(false),
m_non_pointer_isa_cache_ap(
NonPointerISACache::CreateInstance(*this, objc_module_sp)),
m_tagged_pointer_vendor_ap(
TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)),
m_encoding_to_type_sp(), m_noclasses_warning_emitted(false),
m_CFBoolean_values() {
static const ConstString g_gdb_object_getClass("gdb_object_getClass");
m_has_object_getClass = (objc_module_sp->FindFirstSymbolWithNameAndType(
g_gdb_object_getClass, eSymbolTypeCode) != NULL);
}
bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
ValueObject &in_value, lldb::DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address,
Value::ValueType &value_type, bool allow_swift) {
// We should never get here with a null process...
assert(m_process != NULL);
// The Runtime is attached to a particular process, you shouldn't pass in a
// value from another process.
// Note, however, the process might be NULL (e.g. if the value was made with
// SBTarget::EvaluateExpression...)
// in which case it is sufficient if the target's match:
Process *process = in_value.GetProcessSP().get();
if (process)
assert(process == m_process);
else
assert(in_value.GetTargetSP().get() == m_process->CalculateTarget().get());
class_type_or_name.Clear();
value_type = Value::ValueType::eValueTypeScalar;
// Make sure we can have a dynamic value before starting...
if (CouldHaveDynamicValue(in_value, allow_swift)) {
// First job, pull out the address at 0 offset from the object That will be
// the ISA pointer.
ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(in_value));
if (objc_class_sp) {
const addr_t object_ptr = in_value.GetPointerValue();
address.SetRawAddress(object_ptr);
ConstString class_name(objc_class_sp->GetClassName());
class_type_or_name.SetName(class_name);
TypeSP type_sp(objc_class_sp->GetType());
if (type_sp)
class_type_or_name.SetTypeSP(type_sp);
else {
type_sp = LookupInCompleteClassCache(class_name);
if (type_sp) {
objc_class_sp->SetType(type_sp);
class_type_or_name.SetTypeSP(type_sp);
} else {
// try to go for a CompilerType at least
DeclVendor *vendor = GetDeclVendor();
if (vendor) {
std::vector<clang::NamedDecl *> decls;
if (vendor->FindDecls(class_name, false, 1, decls) && decls.size())
class_type_or_name.SetCompilerType(
ClangASTContext::GetTypeForDecl(decls[0]));
}
}
}
}
}
return class_type_or_name.IsEmpty() == false;
}
bool AppleObjCRuntimeV2::GetDynamicTypeAndAddress(
ValueObject &in_value, DynamicValueType use_dynamic,
TypeAndOrName &class_type_or_name, Address &address,
Value::ValueType &value_type) {
return GetDynamicTypeAndAddress(in_value, use_dynamic, class_type_or_name,
address, value_type,
/* allow_swift = */ false);
}
//------------------------------------------------------------------
// Static Functions
//------------------------------------------------------------------
LanguageRuntime *AppleObjCRuntimeV2::CreateInstance(Process *process,
LanguageType language) {
// FIXME: This should be a MacOS or iOS process, and we need to look for the
// OBJC section to make
// sure we aren't using the V1 runtime.
if (language == eLanguageTypeObjC) {
ModuleSP objc_module_sp;
if (AppleObjCRuntime::GetObjCVersion(process, objc_module_sp) ==
ObjCRuntimeVersions::eAppleObjC_V2)
return new AppleObjCRuntimeV2(process, objc_module_sp);
else
return NULL;
} else
return NULL;
}
static OptionDefinition g_objc_classtable_dump_options[] = {
{LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument,
nullptr, nullptr, 0, eArgTypeNone,
"Print ivar and method information in detail"}};
class CommandObjectObjC_ClassTable_Dump : public CommandObjectParsed {
public:
class CommandOptions : public Options {
public:
CommandOptions() : Options(), m_verbose(false, false) {}
~CommandOptions() override = default;
Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override {
Error error;
const int short_option = m_getopt_table[option_idx].val;
switch (short_option) {
case 'v':
m_verbose.SetCurrentValue(true);
m_verbose.SetOptionWasSet();
break;
default:
error.SetErrorStringWithFormat("unrecognized short option '%c'",
short_option);
break;
}
return error;
}
void OptionParsingStarting(ExecutionContext *execution_context) override {
m_verbose.Clear();
}
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_objc_classtable_dump_options);
}
OptionValueBoolean m_verbose;
};
CommandObjectObjC_ClassTable_Dump(CommandInterpreter &interpreter)
: CommandObjectParsed(
interpreter, "dump", "Dump information on Objective-C classes "
"known to the current process.",
"language objc class-table dump",
eCommandRequiresProcess | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused),
m_options() {
CommandArgumentEntry arg;
CommandArgumentData index_arg;
// Define the first (and only) variant of this arg.
index_arg.arg_type = eArgTypeRegularExpression;
index_arg.arg_repetition = eArgRepeatOptional;
// There is only one variant this argument could be; put it into the
// argument entry.
arg.push_back(index_arg);
// Push the data for the first argument into the m_arguments vector.
m_arguments.push_back(arg);
}
~CommandObjectObjC_ClassTable_Dump() override = default;
Options *GetOptions() override { return &m_options; }
protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
std::unique_ptr<RegularExpression> regex_up;
switch (command.GetArgumentCount()) {
case 0:
break;
case 1: {
regex_up.reset(new RegularExpression());
if (!regex_up->Compile(llvm::StringRef::withNullAsEmpty(
command.GetArgumentAtIndex(0)))) {
result.AppendError(
"invalid argument - please provide a valid regular expression");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
break;
}
default: {
result.AppendError("please provide 0 or 1 arguments");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
Process *process = m_exe_ctx.GetProcessPtr();
ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
if (objc_runtime) {
auto iterators_pair = objc_runtime->GetDescriptorIteratorPair();
auto iterator = iterators_pair.first;
auto &std_out = result.GetOutputStream();
for (; iterator != iterators_pair.second; iterator++) {
if (iterator->second) {
const char *class_name =
iterator->second->GetClassName().AsCString("<unknown>");
if (regex_up && class_name &&
!regex_up->Execute(llvm::StringRef(class_name)))
continue;
std_out.Printf("isa = 0x%" PRIx64, iterator->first);
std_out.Printf(" name = %s", class_name);
std_out.Printf(" instance size = %" PRIu64,
iterator->second->GetInstanceSize());
std_out.Printf(" num ivars = %" PRIuPTR,
(uintptr_t)iterator->second->GetNumIVars());
if (auto superclass = iterator->second->GetSuperclass()) {
std_out.Printf(" superclass = %s",
superclass->GetClassName().AsCString("<unknown>"));
}
std_out.Printf("\n");
if (m_options.m_verbose) {
for (size_t i = 0; i < iterator->second->GetNumIVars(); i++) {
auto ivar = iterator->second->GetIVarAtIndex(i);
std_out.Printf(
" ivar name = %s type = %s size = %" PRIu64
" offset = %" PRId32 "\n",
ivar.m_name.AsCString("<unknown>"),
ivar.m_type.GetDisplayTypeName().AsCString("<unknown>"),
ivar.m_size, ivar.m_offset);
}
iterator->second->Describe(
nullptr,
[objc_runtime, &std_out](const char *name,
const char *type) -> bool {
std_out.Printf(" instance method name = %s type = %s\n",
name, type);
return false;
},
[objc_runtime, &std_out](const char *name,
const char *type) -> bool {
std_out.Printf(" class method name = %s type = %s\n", name,
type);
return false;
},
nullptr);
}
} else {
if (regex_up && !regex_up->Execute(llvm::StringRef()))
continue;
std_out.Printf("isa = 0x%" PRIx64 " has no associated class.\n",
iterator->first);
}
}
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true;
} else {
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
CommandOptions m_options;
};
class CommandObjectMultiwordObjC_TaggedPointer_Info
: public CommandObjectParsed {
public:
CommandObjectMultiwordObjC_TaggedPointer_Info(CommandInterpreter &interpreter)
: CommandObjectParsed(
interpreter, "info", "Dump information on a tagged pointer.",
"language objc tagged-pointer info",
eCommandRequiresProcess | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused) {
CommandArgumentEntry arg;
CommandArgumentData index_arg;
// Define the first (and only) variant of this arg.
index_arg.arg_type = eArgTypeAddress;
index_arg.arg_repetition = eArgRepeatPlus;
// There is only one variant this argument could be; put it into the
// argument entry.
arg.push_back(index_arg);
// Push the data for the first argument into the m_arguments vector.
m_arguments.push_back(arg);
}
~CommandObjectMultiwordObjC_TaggedPointer_Info() override = default;
protected:
bool DoExecute(Args &command, CommandReturnObject &result) override {
if (command.GetArgumentCount() == 0) {
result.AppendError("this command requires arguments");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
Process *process = m_exe_ctx.GetProcessPtr();
ExecutionContext exe_ctx(process);
ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
if (objc_runtime) {
ObjCLanguageRuntime::TaggedPointerVendor *tagged_ptr_vendor =
objc_runtime->GetTaggedPointerVendor();
if (tagged_ptr_vendor) {
for (size_t i = 0; i < command.GetArgumentCount(); i++) {
const char *arg_str = command.GetArgumentAtIndex(i);
if (!arg_str)
continue;
Error error;
lldb::addr_t arg_addr = Args::StringToAddress(
&exe_ctx, arg_str, LLDB_INVALID_ADDRESS, &error);
if (arg_addr == 0 || arg_addr == LLDB_INVALID_ADDRESS || error.Fail())
continue;
auto descriptor_sp = tagged_ptr_vendor->GetClassDescriptor(arg_addr);
if (!descriptor_sp)
continue;
uint64_t info_bits = 0;
uint64_t value_bits = 0;
uint64_t payload = 0;
if (descriptor_sp->GetTaggedPointerInfo(&info_bits, &value_bits,
&payload)) {
result.GetOutputStream().Printf(
"0x%" PRIx64 " is tagged.\n\tpayload = 0x%" PRIx64
"\n\tvalue = 0x%" PRIx64 "\n\tinfo bits = 0x%" PRIx64
"\n\tclass = %s\n",
(uint64_t)arg_addr, payload, value_bits, info_bits,
descriptor_sp->GetClassName().AsCString("<unknown>"));
} else {
result.GetOutputStream().Printf("0x%" PRIx64 " is not tagged.\n",
(uint64_t)arg_addr);
}
}
} else {
result.AppendError("current process has no tagged pointer support");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
return true;
} else {
result.AppendError("current process has no Objective-C runtime loaded");
result.SetStatus(lldb::eReturnStatusFailed);
return false;
}
}
};
class CommandObjectMultiwordObjC_ClassTable : public CommandObjectMultiword {
public:
CommandObjectMultiwordObjC_ClassTable(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "class-table",
"Commands for operating on the Objective-C class table.",
"class-table <subcommand> [<subcommand-options>]") {
LoadSubCommand(
"dump",
CommandObjectSP(new CommandObjectObjC_ClassTable_Dump(interpreter)));
}
~CommandObjectMultiwordObjC_ClassTable() override = default;
};
class CommandObjectMultiwordObjC_TaggedPointer : public CommandObjectMultiword {
public:
CommandObjectMultiwordObjC_TaggedPointer(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "tagged-pointer",
"Commands for operating on Objective-C tagged pointers.",
"class-table <subcommand> [<subcommand-options>]") {
LoadSubCommand(
"info",
CommandObjectSP(
new CommandObjectMultiwordObjC_TaggedPointer_Info(interpreter)));
}
~CommandObjectMultiwordObjC_TaggedPointer() override = default;
};
class CommandObjectMultiwordObjC : public CommandObjectMultiword {
public:
CommandObjectMultiwordObjC(CommandInterpreter &interpreter)
: CommandObjectMultiword(
interpreter, "objc",
"Commands for operating on the Objective-C language runtime.",
"objc <subcommand> [<subcommand-options>]") {
LoadSubCommand("class-table",
CommandObjectSP(
new CommandObjectMultiwordObjC_ClassTable(interpreter)));
LoadSubCommand("tagged-pointer",
CommandObjectSP(new CommandObjectMultiwordObjC_TaggedPointer(
interpreter)));
}
~CommandObjectMultiwordObjC() override = default;
};
void AppleObjCRuntimeV2::Initialize() {
PluginManager::RegisterPlugin(
GetPluginNameStatic(), "Apple Objective C Language Runtime - Version 2",
CreateInstance,
[](CommandInterpreter &interpreter) -> lldb::CommandObjectSP {
return CommandObjectSP(new CommandObjectMultiwordObjC(interpreter));
});
}
void AppleObjCRuntimeV2::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
}
lldb_private::ConstString AppleObjCRuntimeV2::GetPluginNameStatic() {
static ConstString g_name("apple-objc-v2");
return g_name;
}
//------------------------------------------------------------------
// PluginInterface protocol
//------------------------------------------------------------------
lldb_private::ConstString AppleObjCRuntimeV2::GetPluginName() {
return GetPluginNameStatic();
}
uint32_t AppleObjCRuntimeV2::GetPluginVersion() { return 1; }
BreakpointResolverSP
AppleObjCRuntimeV2::CreateExceptionResolver(Breakpoint *bkpt, bool catch_bp,
bool throw_bp) {
BreakpointResolverSP resolver_sp;
if (throw_bp)
resolver_sp.reset(new BreakpointResolverName(
bkpt, "objc_exception_throw", eFunctionNameTypeBase,
eLanguageTypeUnknown, Breakpoint::Exact, 0, eLazyBoolNo));
// FIXME: We don't do catch breakpoints for ObjC yet.
// Should there be some way for the runtime to specify what it can do in this
// regard?
return resolver_sp;
}
UtilityFunction *AppleObjCRuntimeV2::CreateObjectChecker(const char *name) {
char check_function_code[2048];
int len = 0;
if (m_has_object_getClass) {
len = ::snprintf(check_function_code, sizeof(check_function_code),
"extern \"C\" void *gdb_object_getClass(void *); "
" \n"
"extern \"C\" int printf(const char *format, ...); "
" \n"
"extern \"C\" void "
" \n"
"%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) "
" \n"
"{ "
" \n"
" if ($__lldb_arg_obj == (void *)0) "
" \n"
" return; // nil is ok "
" \n"
" if (!gdb_object_getClass($__lldb_arg_obj)) "
" \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" else if ($__lldb_arg_selector != (void *)0) "
" \n"
" { "
" \n"
" signed char responds = (signed char) [(id) "
"$__lldb_arg_obj \n"
" "
"respondsToSelector: \n"
" (struct "
"objc_selector *) $__lldb_arg_selector]; \n"
" if (responds == (signed char) 0) "
" \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" } "
" \n"
"} "
" \n",
name);
} else {
len = ::snprintf(check_function_code, sizeof(check_function_code),
"extern \"C\" void *gdb_class_getClass(void *); "
" \n"
"extern \"C\" int printf(const char *format, ...); "
" \n"
"extern \"C\" void "
" \n"
"%s(void *$__lldb_arg_obj, void *$__lldb_arg_selector) "
" \n"
"{ "
" \n"
" if ($__lldb_arg_obj == (void *)0) "
" \n"
" return; // nil is ok "
" \n"
" void **$isa_ptr = (void **)$__lldb_arg_obj; "
" \n"
" if (*$isa_ptr == (void *)0 || "
"!gdb_class_getClass(*$isa_ptr)) \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" else if ($__lldb_arg_selector != (void *)0) "
" \n"
" { "
" \n"
" signed char responds = (signed char) [(id) "
"$__lldb_arg_obj \n"
" "
"respondsToSelector: \n"
" (struct "
"objc_selector *) $__lldb_arg_selector]; \n"
" if (responds == (signed char) 0) "
" \n"
" *((volatile int *)0) = 'ocgc'; "
" \n"
" } "
" \n"
"} "
" \n",
name);
}
assert(len < (int)sizeof(check_function_code));
Error error;
return GetTargetRef().GetUtilityFunctionForLanguage(
check_function_code, eLanguageTypeObjC, name, error);
}
size_t AppleObjCRuntimeV2::GetByteOffsetForIvar(CompilerType &parent_ast_type,
const char *ivar_name) {
uint32_t ivar_offset = LLDB_INVALID_IVAR_OFFSET;
const char *class_name = parent_ast_type.GetConstTypeName().AsCString();
if (class_name && class_name[0] && ivar_name && ivar_name[0]) {
//----------------------------------------------------------------------
// Make the objective C V2 mangled name for the ivar offset from the
// class name and ivar name
//----------------------------------------------------------------------
std::string buffer("OBJC_IVAR_$_");
buffer.append(class_name);
buffer.push_back('.');
buffer.append(ivar_name);
ConstString ivar_const_str(buffer.c_str());
//----------------------------------------------------------------------
// Try to get the ivar offset address from the symbol table first using
// the name we created above
//----------------------------------------------------------------------
SymbolContextList sc_list;
Target &target = m_process->GetTarget();
target.GetImages().FindSymbolsWithNameAndType(ivar_const_str,
eSymbolTypeObjCIVar, sc_list);
addr_t ivar_offset_address = LLDB_INVALID_ADDRESS;
Error error;
SymbolContext ivar_offset_symbol;
if (sc_list.GetSize() == 1 &&
sc_list.GetContextAtIndex(0, ivar_offset_symbol)) {
if (ivar_offset_symbol.symbol)
ivar_offset_address =
ivar_offset_symbol.symbol->GetLoadAddress(&target);
}
//----------------------------------------------------------------------
// If we didn't get the ivar offset address from the symbol table, fall
// back to getting it from the runtime
//----------------------------------------------------------------------
if (ivar_offset_address == LLDB_INVALID_ADDRESS)
ivar_offset_address = LookupRuntimeSymbol(ivar_const_str);
if (ivar_offset_address != LLDB_INVALID_ADDRESS)
ivar_offset = m_process->ReadUnsignedIntegerFromMemory(
ivar_offset_address, 4, LLDB_INVALID_IVAR_OFFSET, error);
}
return ivar_offset;
}
// tagged pointers are special not-a-real-pointer values that contain both type
// and value information
// this routine attempts to check with as little computational effort as
// possible whether something
// could possibly be a tagged pointer - false positives are possible but false
// negatives shouldn't
bool AppleObjCRuntimeV2::IsTaggedPointer(addr_t ptr) {
if (!m_tagged_pointer_vendor_ap)
return false;
return m_tagged_pointer_vendor_ap->IsPossibleTaggedPointer(ptr);
}
class RemoteNXMapTable {
public:
RemoteNXMapTable()
: m_count(0), m_num_buckets_minus_one(0),
m_buckets_ptr(LLDB_INVALID_ADDRESS), m_process(NULL),
m_end_iterator(*this, -1), m_load_addr(LLDB_INVALID_ADDRESS),
m_map_pair_size(0), m_invalid_key(0) {}
void Dump() {
printf("RemoteNXMapTable.m_load_addr = 0x%" PRIx64 "\n", m_load_addr);
printf("RemoteNXMapTable.m_count = %u\n", m_count);
printf("RemoteNXMapTable.m_num_buckets_minus_one = %u\n",
m_num_buckets_minus_one);
printf("RemoteNXMapTable.m_buckets_ptr = 0x%" PRIX64 "\n", m_buckets_ptr);
}
bool ParseHeader(Process *process, lldb::addr_t load_addr) {
m_process = process;
m_load_addr = load_addr;
m_map_pair_size = m_process->GetAddressByteSize() * 2;
m_invalid_key =
m_process->GetAddressByteSize() == 8 ? UINT64_MAX : UINT32_MAX;
Error err;
// This currently holds true for all platforms we support, but we might
// need to change this to use get the actually byte size of "unsigned"
// from the target AST...
const uint32_t unsigned_byte_size = sizeof(uint32_t);
// Skip the prototype as we don't need it (const struct +NXMapTablePrototype
// *prototype)
bool success = true;
if (load_addr == LLDB_INVALID_ADDRESS)
success = false;
else {
lldb::addr_t cursor = load_addr + m_process->GetAddressByteSize();
// unsigned count;
m_count = m_process->ReadUnsignedIntegerFromMemory(
cursor, unsigned_byte_size, 0, err);
if (m_count) {
cursor += unsigned_byte_size;
// unsigned nbBucketsMinusOne;
m_num_buckets_minus_one = m_process->ReadUnsignedIntegerFromMemory(
cursor, unsigned_byte_size, 0, err);
cursor += unsigned_byte_size;
// void *buckets;
m_buckets_ptr = m_process->ReadPointerFromMemory(cursor, err);
success = m_count > 0 && m_buckets_ptr != LLDB_INVALID_ADDRESS;
}
}
if (!success) {
m_count = 0;
m_num_buckets_minus_one = 0;
m_buckets_ptr = LLDB_INVALID_ADDRESS;
}
return success;
}
// const_iterator mimics NXMapState and its code comes from NXInitMapState and
// NXNextMapState.
typedef std::pair<ConstString, ObjCLanguageRuntime::ObjCISA> element;
friend class const_iterator;
class const_iterator {
public:
const_iterator(RemoteNXMapTable &parent, int index)
: m_parent(parent), m_index(index) {
AdvanceToValidIndex();
}
const_iterator(const const_iterator &rhs)
: m_parent(rhs.m_parent), m_index(rhs.m_index) {
// AdvanceToValidIndex() has been called by rhs already.
}
const_iterator &operator=(const const_iterator &rhs) {
// AdvanceToValidIndex() has been called by rhs already.
assert(&m_parent == &rhs.m_parent);
m_index = rhs.m_index;
return *this;
}
bool operator==(const const_iterator &rhs) const {
if (&m_parent != &rhs.m_parent)
return false;
if (m_index != rhs.m_index)
return false;
return true;
}
bool operator!=(const const_iterator &rhs) const {
return !(operator==(rhs));
}
const_iterator &operator++() {
AdvanceToValidIndex();
return *this;
}
const element operator*() const {
if (m_index == -1) {
// TODO find a way to make this an error, but not an assert
return element();
}
lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
size_t map_pair_size = m_parent.m_map_pair_size;
lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
Error err;
lldb::addr_t key =
m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
if (!err.Success())
return element();
lldb::addr_t value = m_parent.m_process->ReadPointerFromMemory(
pair_ptr + m_parent.m_process->GetAddressByteSize(), err);
if (!err.Success())
return element();
std::string key_string;
m_parent.m_process->ReadCStringFromMemory(key, key_string, err);
if (!err.Success())
return element();
return element(ConstString(key_string.c_str()),
(ObjCLanguageRuntime::ObjCISA)value);
}
private:
void AdvanceToValidIndex() {
if (m_index == -1)
return;
const lldb::addr_t pairs_ptr = m_parent.m_buckets_ptr;
const size_t map_pair_size = m_parent.m_map_pair_size;
const lldb::addr_t invalid_key = m_parent.m_invalid_key;
Error err;
while (m_index--) {
lldb::addr_t pair_ptr = pairs_ptr + (m_index * map_pair_size);
lldb::addr_t key =
m_parent.m_process->ReadPointerFromMemory(pair_ptr, err);
if (!err.Success()) {
m_index = -1;
return;
}
if (key != invalid_key)
return;
}
}
RemoteNXMapTable &m_parent;
int m_index;
};
const_iterator begin() {
return const_iterator(*this, m_num_buckets_minus_one + 1);
}
const_iterator end() { return m_end_iterator; }
uint32_t GetCount() const { return m_count; }
uint32_t GetBucketCount() const { return m_num_buckets_minus_one; }
lldb::addr_t GetBucketDataPointer() const { return m_buckets_ptr; }
lldb::addr_t GetTableLoadAddress() const { return m_load_addr; }
private:
// contents of _NXMapTable struct
uint32_t m_count;
uint32_t m_num_buckets_minus_one;
lldb::addr_t m_buckets_ptr;
lldb_private::Process *m_process;
const_iterator m_end_iterator;
lldb::addr_t m_load_addr;
size_t m_map_pair_size;
lldb::addr_t m_invalid_key;
};
AppleObjCRuntimeV2::HashTableSignature::HashTableSignature()
: m_count(0), m_num_buckets(0), m_buckets_ptr(0) {}
void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature(
const RemoteNXMapTable &hash_table) {
m_count = hash_table.GetCount();
m_num_buckets = hash_table.GetBucketCount();
m_buckets_ptr = hash_table.GetBucketDataPointer();
}
bool AppleObjCRuntimeV2::HashTableSignature::NeedsUpdate(
Process *process, AppleObjCRuntimeV2 *runtime,
RemoteNXMapTable &hash_table) {
if (!hash_table.ParseHeader(process, runtime->GetISAHashTablePointer())) {
return false; // Failed to parse the header, no need to update anything
}
// Check with out current signature and return true if the count,
// number of buckets or the hash table address changes.
if (m_count == hash_table.GetCount() &&
m_num_buckets == hash_table.GetBucketCount() &&
m_buckets_ptr == hash_table.GetBucketDataPointer()) {
// Hash table hasn't changed
return false;
}
// Hash table data has changed, we need to update
return true;
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::GetClassDescriptorFromISA(ObjCISA isa) {
ObjCLanguageRuntime::ClassDescriptorSP class_descriptor_sp;
if (m_non_pointer_isa_cache_ap.get())
class_descriptor_sp = m_non_pointer_isa_cache_ap->GetClassDescriptor(isa);
if (!class_descriptor_sp)
class_descriptor_sp = ObjCLanguageRuntime::GetClassDescriptorFromISA(isa);
return class_descriptor_sp;
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::GetClassDescriptor(ValueObject &valobj) {
ClassDescriptorSP objc_class_sp;
if (valobj.IsBaseClass()) {
ValueObject *parent = valobj.GetParent();
// if I am my own parent, bail out of here fast..
if (parent && parent != &valobj) {
ClassDescriptorSP parent_descriptor_sp = GetClassDescriptor(*parent);
if (parent_descriptor_sp)
return parent_descriptor_sp->GetSuperclass();
}
return nullptr;
}
// if we get an invalid VO (which might still happen when playing around
// with pointers returned by the expression parser, don't consider this
// a valid ObjC object)
if (valobj.GetCompilerType().IsValid()) {
addr_t isa_pointer = valobj.GetPointerValue();
// tagged pointer
if (IsTaggedPointer(isa_pointer)) {
return m_tagged_pointer_vendor_ap->GetClassDescriptor(isa_pointer);
} else {
ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
Process *process = exe_ctx.GetProcessPtr();
if (process) {
Error error;
ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
if (isa != LLDB_INVALID_ADDRESS) {
objc_class_sp = GetClassDescriptorFromISA(isa);
if (isa && !objc_class_sp) {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log)
log->Printf("0x%" PRIx64
": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
"not in class descriptor cache 0x%" PRIx64,
isa_pointer, isa);
}
}
}
}
}
return objc_class_sp;
}
lldb::addr_t AppleObjCRuntimeV2::GetISAHashTablePointer() {
if (m_isa_hash_table_ptr == LLDB_INVALID_ADDRESS) {
Process *process = GetProcess();
ModuleSP objc_module_sp(GetObjCModule());
if (!objc_module_sp)
return LLDB_INVALID_ADDRESS;
static ConstString g_gdb_objc_realized_classes("gdb_objc_realized_classes");
const Symbol *symbol = objc_module_sp->FindFirstSymbolWithNameAndType(
g_gdb_objc_realized_classes, lldb::eSymbolTypeAny);
if (symbol) {
lldb::addr_t gdb_objc_realized_classes_ptr =
symbol->GetLoadAddress(&process->GetTarget());
if (gdb_objc_realized_classes_ptr != LLDB_INVALID_ADDRESS) {
Error error;
m_isa_hash_table_ptr = process->ReadPointerFromMemory(
gdb_objc_realized_classes_ptr, error);
}
}
}
return m_isa_hash_table_ptr;
}
AppleObjCRuntimeV2::DescriptorMapUpdateResult
AppleObjCRuntimeV2::UpdateISAToDescriptorMapDynamic(
RemoteNXMapTable &hash_table) {
Process *process = GetProcess();
if (process == NULL)
return DescriptorMapUpdateResult::Fail();
uint32_t num_class_infos = 0;
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
ExecutionContext exe_ctx;
ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
if (!thread_sp)
return DescriptorMapUpdateResult::Fail();
thread_sp->CalculateExecutionContext(exe_ctx);
ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
if (!ast)
return DescriptorMapUpdateResult::Fail();
Address function_address;
DiagnosticManager diagnostics;
const uint32_t addr_size = process->GetAddressByteSize();
Error err;
// Read the total number of classes from the hash table
const uint32_t num_classes = hash_table.GetCount();
if (num_classes == 0) {
if (log)
log->Printf("No dynamic classes found in gdb_objc_realized_classes.");
return DescriptorMapUpdateResult::Success(0);
}
// Make some types for our arguments
CompilerType clang_uint32_t_type =
ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
CompilerType clang_void_pointer_type =
ast->GetBasicType(eBasicTypeVoid).GetPointerType();
ValueList arguments;
FunctionCaller *get_class_info_function = nullptr;
if (!m_get_class_info_code.get()) {
Error error;
m_get_class_info_code.reset(GetTargetRef().GetUtilityFunctionForLanguage(
g_get_dynamic_class_info_body, eLanguageTypeObjC,
g_get_dynamic_class_info_name, error));
if (error.Fail()) {
if (log)
log->Printf(
"Failed to get Utility Function for implementation lookup: %s",
error.AsCString());
m_get_class_info_code.reset();
} else {
diagnostics.Clear();
if (!m_get_class_info_code->Install(diagnostics, exe_ctx)) {
if (log) {
log->Printf("Failed to install implementation lookup");
diagnostics.Dump(log);
}
m_get_class_info_code.reset();
}
}
if (!m_get_class_info_code.get())
return DescriptorMapUpdateResult::Fail();
// Next make the runner function for our implementation utility function.
Value value;
value.SetValueType(Value::eValueTypeScalar);
value.SetCompilerType(clang_void_pointer_type);
arguments.PushValue(value);
arguments.PushValue(value);
value.SetValueType(Value::eValueTypeScalar);
value.SetCompilerType(clang_uint32_t_type);
arguments.PushValue(value);
arguments.PushValue(value);
get_class_info_function = m_get_class_info_code->MakeFunctionCaller(
clang_uint32_t_type, arguments, thread_sp, error);
if (error.Fail()) {
if (log)
log->Printf(
"Failed to make function caller for implementation lookup: %s.",
error.AsCString());
return DescriptorMapUpdateResult::Fail();
}
} else {
get_class_info_function = m_get_class_info_code->GetFunctionCaller();
if (!get_class_info_function) {
if (log) {
log->Printf("Failed to get implementation lookup function caller.");
diagnostics.Dump(log);
}
return DescriptorMapUpdateResult::Fail();
}
arguments = get_class_info_function->GetArgumentValues();
}
diagnostics.Clear();
const uint32_t class_info_byte_size = addr_size + 4;
const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
lldb::addr_t class_infos_addr = process->AllocateMemory(
class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err);
if (class_infos_addr == LLDB_INVALID_ADDRESS) {
if (log)
log->Printf("unable to allocate %" PRIu32
" bytes in process for shared cache read",
class_infos_byte_size);
return DescriptorMapUpdateResult::Fail();
}
std::lock_guard<std::mutex> guard(m_get_class_info_args_mutex);
// Fill in our function argument values
arguments.GetValueAtIndex(0)->GetScalar() = hash_table.GetTableLoadAddress();
arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
// Only dump the runtime classes from the expression evaluation if the
// log is verbose:
Log *type_log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES);
bool dump_log = type_log && type_log->GetVerbose();
arguments.GetValueAtIndex(3)->GetScalar() = dump_log ? 1 : 0;
bool success = false;
diagnostics.Clear();
// Write our function arguments into the process so we can run our function
if (get_class_info_function->WriteFunctionArguments(
exe_ctx, m_get_class_info_args, arguments, diagnostics)) {
EvaluateExpressionOptions options;
options.SetUnwindOnError(true);
options.SetTryAllThreads(false);
options.SetStopOthers(true);
options.SetIgnoreBreakpoints(true);
options.SetTimeout(g_utility_function_timeout);
Value return_value;
return_value.SetValueType(Value::eValueTypeScalar);
// return_value.SetContext (Value::eContextTypeClangType,
// clang_uint32_t_type);
return_value.SetCompilerType(clang_uint32_t_type);
return_value.GetScalar() = 0;
diagnostics.Clear();
// Run the function
ExpressionResults results = get_class_info_function->ExecuteFunction(
exe_ctx, &m_get_class_info_args, options, diagnostics, return_value);
if (results == eExpressionCompleted) {
// The result is the number of ClassInfo structures that were filled in
num_class_infos = return_value.GetScalar().ULong();
if (log)
log->Printf("Discovered %u ObjC classes\n", num_class_infos);
if (num_class_infos > 0) {
// Read the ClassInfo structures
DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0);
if (process->ReadMemory(class_infos_addr, buffer.GetBytes(),
buffer.GetByteSize(),
err) == buffer.GetByteSize()) {
DataExtractor class_infos_data(buffer.GetBytes(),
buffer.GetByteSize(),
process->GetByteOrder(), addr_size);
ParseClassInfoArray(class_infos_data, num_class_infos);
}
}
success = true;
} else {
if (log) {
log->Printf("Error evaluating our find class name function.");
diagnostics.Dump(log);
}
}
} else {
if (log) {
log->Printf("Error writing function arguments.");
diagnostics.Dump(log);
}
}
// Deallocate the memory we allocated for the ClassInfo array
process->DeallocateMemory(class_infos_addr);
return DescriptorMapUpdateResult(success, num_class_infos);
}
uint32_t AppleObjCRuntimeV2::ParseClassInfoArray(const DataExtractor &data,
uint32_t num_class_infos) {
// Parses an array of "num_class_infos" packed ClassInfo structures:
//
// struct ClassInfo
// {
// Class isa;
// uint32_t hash;
// } __attribute__((__packed__));
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
uint32_t num_parsed = 0;
// Iterate through all ClassInfo structures
lldb::offset_t offset = 0;
for (uint32_t i = 0; i < num_class_infos; ++i) {
ObjCISA isa = data.GetPointer(&offset);
if (isa == 0) {
if (log)
log->Printf(
"AppleObjCRuntimeV2 found NULL isa, ignoring this class info");
continue;
}
// Check if we already know about this ISA, if we do, the info will
// never change, so we can just skip it.
if (ISAIsCached(isa)) {
if (log)
log->Printf("AppleObjCRuntimeV2 found cached isa=0x%" PRIx64
", ignoring this class info",
isa);
offset += 4;
} else {
// Read the 32 bit hash for the class name
const uint32_t name_hash = data.GetU32(&offset);
ClassDescriptorSP descriptor_sp(new ClassDescriptorV2(*this, isa, NULL));
AddClass(isa, descriptor_sp, name_hash);
num_parsed++;
if (log)
log->Printf("AppleObjCRuntimeV2 added isa=0x%" PRIx64
", hash=0x%8.8x, name=%s",
isa, name_hash,
descriptor_sp->GetClassName().AsCString("<unknown>"));
}
}
if (log)
log->Printf("AppleObjCRuntimeV2 parsed %" PRIu32 " class infos",
num_parsed);
return num_parsed;
}
AppleObjCRuntimeV2::DescriptorMapUpdateResult
AppleObjCRuntimeV2::UpdateISAToDescriptorMapSharedCache() {
Process *process = GetProcess();
if (process == NULL)
return DescriptorMapUpdateResult::Fail();
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
ExecutionContext exe_ctx;
ThreadSP thread_sp = process->GetThreadList().GetExpressionExecutionThread();
if (!thread_sp)
return DescriptorMapUpdateResult::Fail();
thread_sp->CalculateExecutionContext(exe_ctx);
ClangASTContext *ast = process->GetTarget().GetScratchClangASTContext();
if (!ast)
return DescriptorMapUpdateResult::Fail();
Address function_address;
DiagnosticManager diagnostics;
const uint32_t addr_size = process->GetAddressByteSize();
Error err;
uint32_t num_class_infos = 0;
const lldb::addr_t objc_opt_ptr = GetSharedCacheReadOnlyAddress();
if (objc_opt_ptr == LLDB_INVALID_ADDRESS)
return DescriptorMapUpdateResult::Fail();
const uint32_t num_classes = 128 * 1024;
// Make some types for our arguments
CompilerType clang_uint32_t_type =
ast->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
CompilerType clang_void_pointer_type =
ast->GetBasicType(eBasicTypeVoid).GetPointerType();
ValueList arguments;
FunctionCaller *get_shared_cache_class_info_function = nullptr;
if (!m_get_shared_cache_class_info_code.get()) {
Error error;
m_get_shared_cache_class_info_code.reset(
GetTargetRef().GetUtilityFunctionForLanguage(
g_get_shared_cache_class_info_body, eLanguageTypeObjC,
g_get_shared_cache_class_info_name, error));
if (error.Fail()) {
if (log)
log->Printf(
"Failed to get Utility function for implementation lookup: %s.",
error.AsCString());
m_get_shared_cache_class_info_code.reset();
} else {
diagnostics.Clear();
if (!m_get_shared_cache_class_info_code->Install(diagnostics, exe_ctx)) {
if (log) {
log->Printf("Failed to install implementation lookup.");
diagnostics.Dump(log);
}
m_get_shared_cache_class_info_code.reset();
}
}
if (!m_get_shared_cache_class_info_code.get())
return DescriptorMapUpdateResult::Fail();
// Next make the function caller for our implementation utility function.
Value value;
value.SetValueType(Value::eValueTypeScalar);
// value.SetContext (Value::eContextTypeClangType, clang_void_pointer_type);
value.SetCompilerType(clang_void_pointer_type);
arguments.PushValue(value);
arguments.PushValue(value);
value.SetValueType(Value::eValueTypeScalar);
// value.SetContext (Value::eContextTypeClangType, clang_uint32_t_type);
value.SetCompilerType(clang_uint32_t_type);
arguments.PushValue(value);
arguments.PushValue(value);
get_shared_cache_class_info_function =
m_get_shared_cache_class_info_code->MakeFunctionCaller(
clang_uint32_t_type, arguments, thread_sp, error);
if (get_shared_cache_class_info_function == nullptr)
return DescriptorMapUpdateResult::Fail();
} else {
get_shared_cache_class_info_function =
m_get_shared_cache_class_info_code->GetFunctionCaller();
if (get_shared_cache_class_info_function == nullptr)
return DescriptorMapUpdateResult::Fail();
arguments = get_shared_cache_class_info_function->GetArgumentValues();
}
diagnostics.Clear();
const uint32_t class_info_byte_size = addr_size + 4;
const uint32_t class_infos_byte_size = num_classes * class_info_byte_size;
lldb::addr_t class_infos_addr = process->AllocateMemory(
class_infos_byte_size, ePermissionsReadable | ePermissionsWritable, err);
if (class_infos_addr == LLDB_INVALID_ADDRESS) {
if (log)
log->Printf("unable to allocate %" PRIu32
" bytes in process for shared cache read",
class_infos_byte_size);
return DescriptorMapUpdateResult::Fail();
}
std::lock_guard<std::mutex> guard(m_get_shared_cache_class_info_args_mutex);
// Fill in our function argument values
arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr;
arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;
arguments.GetValueAtIndex(2)->GetScalar() = class_infos_byte_size;
// Only dump the runtime classes from the expression evaluation if the
// log is verbose:
Log *type_log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES);
bool dump_log = type_log && type_log->GetVerbose();
arguments.GetValueAtIndex(3)->GetScalar() = dump_log ? 1 : 0;
bool success = false;
diagnostics.Clear();
// Write our function arguments into the process so we can run our function
if (get_shared_cache_class_info_function->WriteFunctionArguments(
exe_ctx, m_get_shared_cache_class_info_args, arguments,
diagnostics)) {
EvaluateExpressionOptions options;
options.SetUnwindOnError(true);
options.SetTryAllThreads(false);
options.SetStopOthers(true);
options.SetIgnoreBreakpoints(true);
options.SetTimeout(g_utility_function_timeout);
Value return_value;
return_value.SetValueType(Value::eValueTypeScalar);
// return_value.SetContext (Value::eContextTypeClangType,
// clang_uint32_t_type);
return_value.SetCompilerType(clang_uint32_t_type);
return_value.GetScalar() = 0;
diagnostics.Clear();
// Run the function
ExpressionResults results =
get_shared_cache_class_info_function->ExecuteFunction(
exe_ctx, &m_get_shared_cache_class_info_args, options, diagnostics,
return_value);
if (results == eExpressionCompleted) {
// The result is the number of ClassInfo structures that were filled in
num_class_infos = return_value.GetScalar().ULong();
if (log)
log->Printf("Discovered %u ObjC classes in shared cache\n",
num_class_infos);
#ifdef LLDB_CONFIGURATION_DEBUG
assert(num_class_infos <= num_classes);
#endif
if (num_class_infos > 0) {
if (num_class_infos > num_classes) {
num_class_infos = num_classes;
success = false;
} else {
success = true;
}
// Read the ClassInfo structures
DataBufferHeap buffer(num_class_infos * class_info_byte_size, 0);
if (process->ReadMemory(class_infos_addr, buffer.GetBytes(),
buffer.GetByteSize(),
err) == buffer.GetByteSize()) {
DataExtractor class_infos_data(buffer.GetBytes(),
buffer.GetByteSize(),
process->GetByteOrder(), addr_size);
ParseClassInfoArray(class_infos_data, num_class_infos);
}
} else {
success = true;
}
} else {
if (log) {
log->Printf("Error evaluating our find class name function.");
diagnostics.Dump(log);
}
}
} else {
if (log) {
log->Printf("Error writing function arguments.");
diagnostics.Dump(log);
}
}
// Deallocate the memory we allocated for the ClassInfo array
process->DeallocateMemory(class_infos_addr);
return DescriptorMapUpdateResult(success, num_class_infos);
}
bool AppleObjCRuntimeV2::UpdateISAToDescriptorMapFromMemory(
RemoteNXMapTable &hash_table) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
Process *process = GetProcess();
if (process == NULL)
return false;
uint32_t num_map_table_isas = 0;
ModuleSP objc_module_sp(GetObjCModule());
if (objc_module_sp) {
for (RemoteNXMapTable::element elt : hash_table) {
++num_map_table_isas;
if (ISAIsCached(elt.second))
continue;
ClassDescriptorSP descriptor_sp = ClassDescriptorSP(
new ClassDescriptorV2(*this, elt.second, elt.first.AsCString()));
if (log && log->GetVerbose())
log->Printf("AppleObjCRuntimeV2 added (ObjCISA)0x%" PRIx64
" (%s) from dynamic table to isa->descriptor cache",
elt.second, elt.first.AsCString());
AddClass(elt.second, descriptor_sp, elt.first.AsCString());
}
}
return num_map_table_isas > 0;
}
lldb::addr_t AppleObjCRuntimeV2::GetSharedCacheReadOnlyAddress() {
Process *process = GetProcess();
if (process) {
ModuleSP objc_module_sp(GetObjCModule());
if (objc_module_sp) {
ObjectFile *objc_object = objc_module_sp->GetObjectFile();
if (objc_object) {
SectionList *section_list = objc_module_sp->GetSectionList();
if (section_list) {
SectionSP text_segment_sp(
section_list->FindSectionByName(ConstString("__TEXT")));
if (text_segment_sp) {
SectionSP objc_opt_section_sp(
text_segment_sp->GetChildren().FindSectionByName(
ConstString("__objc_opt_ro")));
if (objc_opt_section_sp) {
return objc_opt_section_sp->GetLoadBaseAddress(
&process->GetTarget());
}
}
}
}
}
}
return LLDB_INVALID_ADDRESS;
}
void AppleObjCRuntimeV2::UpdateISAToDescriptorMapIfNeeded() {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
// Else we need to check with our process to see when the map was updated.
Process *process = GetProcess();
if (process) {
RemoteNXMapTable hash_table;
// Update the process stop ID that indicates the last time we updated the
// map, whether it was successful or not.
m_isa_to_descriptor_stop_id = process->GetStopID();
if (!m_hash_signature.NeedsUpdate(process, this, hash_table))
return;
m_hash_signature.UpdateSignature(hash_table);
// Grab the dynamically loaded objc classes from the hash table in memory
DescriptorMapUpdateResult dynamic_update_result =
UpdateISAToDescriptorMapDynamic(hash_table);
// Now get the objc classes that are baked into the Objective C runtime
// in the shared cache, but only once per process as this data never
// changes
if (!m_loaded_objc_opt) {
// it is legitimately possible for the shared cache to be empty - in that
// case, the dynamic hash table
// will contain all the class information we need; the situation we're
// trying to detect is one where
// we aren't seeing class information from the runtime - in order to
// detect that vs. just the shared cache
// being empty or sparsely populated, we set an arbitrary (very low)
// threshold for the number of classes
// that we want to see in a "good" scenario - anything below that is
// suspicious (Foundation alone has thousands
// of classes)
const uint32_t num_classes_to_warn_at = 500;
DescriptorMapUpdateResult shared_cache_update_result =
UpdateISAToDescriptorMapSharedCache();
if (log)
log->Printf("attempted to read objc class data - results: "
"[dynamic_update]: ran: %s, count: %" PRIu32
" [shared_cache_update]: ran: %s, count: %" PRIu32,
dynamic_update_result.m_update_ran ? "yes" : "no",
dynamic_update_result.m_num_found,
shared_cache_update_result.m_update_ran ? "yes" : "no",
shared_cache_update_result.m_num_found);
// warn if:
// - we could not run either expression
// - we found fewer than num_classes_to_warn_at classes total
if ((false == shared_cache_update_result.m_update_ran) ||
(false == dynamic_update_result.m_update_ran))
WarnIfNoClassesCached(
SharedCacheWarningReason::eExpressionExecutionFailure);
else if (dynamic_update_result.m_num_found +
shared_cache_update_result.m_num_found <
num_classes_to_warn_at)
WarnIfNoClassesCached(SharedCacheWarningReason::eNotEnoughClassesRead);
else
m_loaded_objc_opt = true;
}
} else {
m_isa_to_descriptor_stop_id = UINT32_MAX;
}
}
static bool DoesProcessHaveSharedCache(Process &process) {
PlatformSP platform_sp = process.GetTarget().GetPlatform();
if (!platform_sp)
return true; // this should not happen
ConstString platform_plugin_name = platform_sp->GetPluginName();
if (platform_plugin_name) {
llvm::StringRef platform_plugin_name_sr =
platform_plugin_name.GetStringRef();
if (platform_plugin_name_sr.endswith("-simulator"))
return false;
}
return true;
}
void AppleObjCRuntimeV2::WarnIfNoClassesCached(
SharedCacheWarningReason reason) {
if (m_noclasses_warning_emitted)
return;
if (GetProcess() && !DoesProcessHaveSharedCache(*GetProcess())) {
// Simulators do not have the objc_opt_ro class table so don't actually
// complain to the user
m_noclasses_warning_emitted = true;
return;
}
Debugger &debugger(GetProcess()->GetTarget().GetDebugger());
if (auto stream = debugger.GetAsyncOutputStream()) {
switch (reason) {
case SharedCacheWarningReason::eNotEnoughClassesRead:
stream->PutCString("warning: could not find Objective-C class data in "
"the process. This may reduce the quality of type "
"information available.\n");
m_noclasses_warning_emitted = true;
break;
case SharedCacheWarningReason::eExpressionExecutionFailure:
stream->PutCString("warning: could not execute support code to read "
"Objective-C class data in the process. This may "
"reduce the quality of type information available.\n");
m_noclasses_warning_emitted = true;
break;
}
}
}
ConstString
AppleObjCRuntimeV2::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) {
if (isa == g_objc_Tagged_ISA) {
static const ConstString g_objc_tagged_isa_name("_lldb_Tagged_ObjC_ISA");
return g_objc_tagged_isa_name;
}
if (isa == g_objc_Tagged_ISA_NSAtom) {
static const ConstString g_objc_tagged_isa_nsatom_name("NSAtom");
return g_objc_tagged_isa_nsatom_name;
}
if (isa == g_objc_Tagged_ISA_NSNumber) {
static const ConstString g_objc_tagged_isa_nsnumber_name("NSNumber");
return g_objc_tagged_isa_nsnumber_name;
}
if (isa == g_objc_Tagged_ISA_NSDateTS) {
static const ConstString g_objc_tagged_isa_nsdatets_name("NSDateTS");
return g_objc_tagged_isa_nsdatets_name;
}
if (isa == g_objc_Tagged_ISA_NSManagedObject) {
static const ConstString g_objc_tagged_isa_nsmanagedobject_name(
"NSManagedObject");
return g_objc_tagged_isa_nsmanagedobject_name;
}
if (isa == g_objc_Tagged_ISA_NSDate) {
static const ConstString g_objc_tagged_isa_nsdate_name("NSDate");
return g_objc_tagged_isa_nsdate_name;
}
return ObjCLanguageRuntime::GetActualTypeName(isa);
}
DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() {
if (!m_decl_vendor_ap.get())
m_decl_vendor_ap.reset(new AppleObjCDeclVendor(*this));
return m_decl_vendor_ap.get();
}
lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(const ConstString &name) {
lldb::addr_t ret = LLDB_INVALID_ADDRESS;
const char *name_cstr = name.AsCString();
if (name_cstr) {
llvm::StringRef name_strref(name_cstr);
static const llvm::StringRef ivar_prefix("OBJC_IVAR_$_");
static const llvm::StringRef class_prefix("OBJC_CLASS_$_");
if (name_strref.startswith(ivar_prefix)) {
llvm::StringRef ivar_skipped_prefix =
name_strref.substr(ivar_prefix.size());
std::pair<llvm::StringRef, llvm::StringRef> class_and_ivar =
ivar_skipped_prefix.split('.');
if (class_and_ivar.first.size() && class_and_ivar.second.size()) {
const ConstString class_name_cs(class_and_ivar.first);
ClassDescriptorSP descriptor =
ObjCLanguageRuntime::GetClassDescriptorFromClassName(class_name_cs);
if (descriptor) {
const ConstString ivar_name_cs(class_and_ivar.second);
const char *ivar_name_cstr = ivar_name_cs.AsCString();
auto ivar_func = [&ret, ivar_name_cstr](
const char *name, const char *type, lldb::addr_t offset_addr,
uint64_t size) -> lldb::addr_t {
if (!strcmp(name, ivar_name_cstr)) {
ret = offset_addr;
return true;
}
return false;
};
descriptor->Describe(
std::function<void(ObjCISA)>(nullptr),
std::function<bool(const char *, const char *)>(nullptr),
std::function<bool(const char *, const char *)>(nullptr),
ivar_func);
}
}
} else if (name_strref.startswith(class_prefix)) {
llvm::StringRef class_skipped_prefix =
name_strref.substr(class_prefix.size());
const ConstString class_name_cs(class_skipped_prefix);
ClassDescriptorSP descriptor =
GetClassDescriptorFromClassName(class_name_cs);
if (descriptor)
ret = descriptor->GetISA();
}
}
return ret;
}
AppleObjCRuntimeV2::NonPointerISACache *
AppleObjCRuntimeV2::NonPointerISACache::CreateInstance(
AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) {
Process *process(runtime.GetProcess());
Error error;
auto objc_debug_isa_magic_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_isa_magic_mask"), objc_module_sp, error);
if (error.Fail())
return NULL;
auto objc_debug_isa_magic_value = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_isa_magic_value"), objc_module_sp,
error);
if (error.Fail())
return NULL;
auto objc_debug_isa_class_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_isa_class_mask"), objc_module_sp, error);
if (error.Fail())
return NULL;
// we might want to have some rules to outlaw these other values (e.g if the
// mask is zero but the value is non-zero, ...)
return new NonPointerISACache(runtime, objc_debug_isa_class_mask,
objc_debug_isa_magic_mask,
objc_debug_isa_magic_value);
}
AppleObjCRuntimeV2::TaggedPointerVendorV2 *
AppleObjCRuntimeV2::TaggedPointerVendorV2::CreateInstance(
AppleObjCRuntimeV2 &runtime, const lldb::ModuleSP &objc_module_sp) {
Process *process(runtime.GetProcess());
Error error;
auto objc_debug_taggedpointer_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_mask"), objc_module_sp,
error);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_slot_shift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_slot_shift"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_slot_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_slot_mask"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_payload_lshift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_payload_lshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_payload_rshift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_payload_rshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
auto objc_debug_taggedpointer_classes = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_classes"), objc_module_sp,
error, false);
if (error.Fail())
return new TaggedPointerVendorLegacy(runtime);
// try to detect the "extended tagged pointer" variables - if any are missing,
// use the non-extended vendor
do {
auto objc_debug_taggedpointer_ext_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_mask"),
objc_module_sp, error);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_slot_shift = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_slot_shift"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_slot_mask = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_slot_mask"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_classes = ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_classes"),
objc_module_sp, error, false);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_payload_lshift =
ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_payload_lshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
auto objc_debug_taggedpointer_ext_payload_rshift =
ExtractRuntimeGlobalSymbol(
process, ConstString("objc_debug_taggedpointer_ext_payload_rshift"),
objc_module_sp, error, true, 4);
if (error.Fail())
break;
return new TaggedPointerVendorExtended(
runtime, objc_debug_taggedpointer_mask,
objc_debug_taggedpointer_ext_mask, objc_debug_taggedpointer_slot_shift,
objc_debug_taggedpointer_ext_slot_shift,
objc_debug_taggedpointer_slot_mask,
objc_debug_taggedpointer_ext_slot_mask,
objc_debug_taggedpointer_payload_lshift,
objc_debug_taggedpointer_payload_rshift,
objc_debug_taggedpointer_ext_payload_lshift,
objc_debug_taggedpointer_ext_payload_rshift,
objc_debug_taggedpointer_classes, objc_debug_taggedpointer_ext_classes);
} while (false);
// we might want to have some rules to outlaw these values (e.g if the table's
// address is zero)
return new TaggedPointerVendorRuntimeAssisted(
runtime, objc_debug_taggedpointer_mask,
objc_debug_taggedpointer_slot_shift, objc_debug_taggedpointer_slot_mask,
objc_debug_taggedpointer_payload_lshift,
objc_debug_taggedpointer_payload_rshift,
objc_debug_taggedpointer_classes);
}
bool AppleObjCRuntimeV2::TaggedPointerVendorLegacy::IsPossibleTaggedPointer(
lldb::addr_t ptr) {
return (ptr & 1);
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::TaggedPointerVendorLegacy::GetClassDescriptor(
lldb::addr_t ptr) {
if (!IsPossibleTaggedPointer(ptr))
return ObjCLanguageRuntime::ClassDescriptorSP();
uint32_t foundation_version = m_runtime.GetFoundationVersion();
if (foundation_version == LLDB_INVALID_MODULE_VERSION)
return ObjCLanguageRuntime::ClassDescriptorSP();
uint64_t class_bits = (ptr & 0xE) >> 1;
ConstString name;
static ConstString g_NSAtom("NSAtom");
static ConstString g_NSNumber("NSNumber");
static ConstString g_NSDateTS("NSDateTS");
static ConstString g_NSManagedObject("NSManagedObject");
static ConstString g_NSDate("NSDate");
if (foundation_version >= 900) {
switch (class_bits) {
case 0:
name = g_NSAtom;
break;
case 3:
name = g_NSNumber;
break;
case 4:
name = g_NSDateTS;
break;
case 5:
name = g_NSManagedObject;
break;
case 6:
name = g_NSDate;
break;
default:
return ObjCLanguageRuntime::ClassDescriptorSP();
}
} else {
switch (class_bits) {
case 1:
name = g_NSNumber;
break;
case 5:
name = g_NSManagedObject;
break;
case 6:
name = g_NSDate;
break;
case 7:
name = g_NSDateTS;
break;
default:
return ObjCLanguageRuntime::ClassDescriptorSP();
}
}
return ClassDescriptorSP(new ClassDescriptorV2Tagged(name, ptr));
}
AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::
TaggedPointerVendorRuntimeAssisted(
AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
uint32_t objc_debug_taggedpointer_slot_shift,
uint32_t objc_debug_taggedpointer_slot_mask,
uint32_t objc_debug_taggedpointer_payload_lshift,
uint32_t objc_debug_taggedpointer_payload_rshift,
lldb::addr_t objc_debug_taggedpointer_classes)
: TaggedPointerVendorV2(runtime), m_cache(),
m_objc_debug_taggedpointer_mask(objc_debug_taggedpointer_mask),
m_objc_debug_taggedpointer_slot_shift(
objc_debug_taggedpointer_slot_shift),
m_objc_debug_taggedpointer_slot_mask(objc_debug_taggedpointer_slot_mask),
m_objc_debug_taggedpointer_payload_lshift(
objc_debug_taggedpointer_payload_lshift),
m_objc_debug_taggedpointer_payload_rshift(
objc_debug_taggedpointer_payload_rshift),
m_objc_debug_taggedpointer_classes(objc_debug_taggedpointer_classes) {}
bool AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::
IsPossibleTaggedPointer(lldb::addr_t ptr) {
return (ptr & m_objc_debug_taggedpointer_mask) != 0;
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(
lldb::addr_t ptr) {
ClassDescriptorSP actual_class_descriptor_sp;
uint64_t data_payload;
if (!IsPossibleTaggedPointer(ptr))
return ObjCLanguageRuntime::ClassDescriptorSP();
uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_slot_shift) &
m_objc_debug_taggedpointer_slot_mask;
CacheIterator iterator = m_cache.find(slot), end = m_cache.end();
if (iterator != end) {
actual_class_descriptor_sp = iterator->second;
} else {
Process *process(m_runtime.GetProcess());
uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
m_objc_debug_taggedpointer_classes;
Error error;
uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
if (error.Fail() || slot_data == 0 ||
slot_data == uintptr_t(LLDB_INVALID_ADDRESS))
return nullptr;
actual_class_descriptor_sp =
m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
if (!actual_class_descriptor_sp)
return ObjCLanguageRuntime::ClassDescriptorSP();
m_cache[slot] = actual_class_descriptor_sp;
}
data_payload =
(((uint64_t)ptr << m_objc_debug_taggedpointer_payload_lshift) >>
m_objc_debug_taggedpointer_payload_rshift);
return ClassDescriptorSP(
new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload));
}
AppleObjCRuntimeV2::TaggedPointerVendorExtended::TaggedPointerVendorExtended(
AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_taggedpointer_mask,
uint64_t objc_debug_taggedpointer_ext_mask,
uint32_t objc_debug_taggedpointer_slot_shift,
uint32_t objc_debug_taggedpointer_ext_slot_shift,
uint32_t objc_debug_taggedpointer_slot_mask,
uint32_t objc_debug_taggedpointer_ext_slot_mask,
uint32_t objc_debug_taggedpointer_payload_lshift,
uint32_t objc_debug_taggedpointer_payload_rshift,
uint32_t objc_debug_taggedpointer_ext_payload_lshift,
uint32_t objc_debug_taggedpointer_ext_payload_rshift,
lldb::addr_t objc_debug_taggedpointer_classes,
lldb::addr_t objc_debug_taggedpointer_ext_classes)
: TaggedPointerVendorRuntimeAssisted(
runtime, objc_debug_taggedpointer_mask,
objc_debug_taggedpointer_slot_shift,
objc_debug_taggedpointer_slot_mask,
objc_debug_taggedpointer_payload_lshift,
objc_debug_taggedpointer_payload_rshift,
objc_debug_taggedpointer_classes),
m_ext_cache(),
m_objc_debug_taggedpointer_ext_mask(objc_debug_taggedpointer_ext_mask),
m_objc_debug_taggedpointer_ext_slot_shift(
objc_debug_taggedpointer_ext_slot_shift),
m_objc_debug_taggedpointer_ext_slot_mask(
objc_debug_taggedpointer_ext_slot_mask),
m_objc_debug_taggedpointer_ext_payload_lshift(
objc_debug_taggedpointer_ext_payload_lshift),
m_objc_debug_taggedpointer_ext_payload_rshift(
objc_debug_taggedpointer_ext_payload_rshift),
m_objc_debug_taggedpointer_ext_classes(
objc_debug_taggedpointer_ext_classes) {}
bool AppleObjCRuntimeV2::TaggedPointerVendorExtended::
IsPossibleExtendedTaggedPointer(lldb::addr_t ptr) {
if (!IsPossibleTaggedPointer(ptr))
return false;
if (m_objc_debug_taggedpointer_ext_mask == 0)
return false;
return ((ptr & m_objc_debug_taggedpointer_ext_mask) ==
m_objc_debug_taggedpointer_ext_mask);
}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::TaggedPointerVendorExtended::GetClassDescriptor(
lldb::addr_t ptr) {
ClassDescriptorSP actual_class_descriptor_sp;
uint64_t data_payload;
if (!IsPossibleTaggedPointer(ptr))
return ObjCLanguageRuntime::ClassDescriptorSP();
if (!IsPossibleExtendedTaggedPointer(ptr))
return this->TaggedPointerVendorRuntimeAssisted::GetClassDescriptor(ptr);
uintptr_t slot = (ptr >> m_objc_debug_taggedpointer_ext_slot_shift) &
m_objc_debug_taggedpointer_ext_slot_mask;
CacheIterator iterator = m_ext_cache.find(slot), end = m_ext_cache.end();
if (iterator != end) {
actual_class_descriptor_sp = iterator->second;
} else {
Process *process(m_runtime.GetProcess());
uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
m_objc_debug_taggedpointer_ext_classes;
Error error;
uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
if (error.Fail() || slot_data == 0 ||
slot_data == uintptr_t(LLDB_INVALID_ADDRESS))
return nullptr;
actual_class_descriptor_sp =
m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
if (!actual_class_descriptor_sp)
return ObjCLanguageRuntime::ClassDescriptorSP();
m_ext_cache[slot] = actual_class_descriptor_sp;
}
data_payload =
(((uint64_t)ptr << m_objc_debug_taggedpointer_ext_payload_lshift) >>
m_objc_debug_taggedpointer_ext_payload_rshift);
return ClassDescriptorSP(
new ClassDescriptorV2Tagged(actual_class_descriptor_sp, data_payload));
}
AppleObjCRuntimeV2::NonPointerISACache::NonPointerISACache(
AppleObjCRuntimeV2 &runtime, uint64_t objc_debug_isa_class_mask,
uint64_t objc_debug_isa_magic_mask, uint64_t objc_debug_isa_magic_value)
: m_runtime(runtime), m_cache(),
m_objc_debug_isa_class_mask(objc_debug_isa_class_mask),
m_objc_debug_isa_magic_mask(objc_debug_isa_magic_mask),
m_objc_debug_isa_magic_value(objc_debug_isa_magic_value) {}
ObjCLanguageRuntime::ClassDescriptorSP
AppleObjCRuntimeV2::NonPointerISACache::GetClassDescriptor(ObjCISA isa) {
ObjCISA real_isa = 0;
if (EvaluateNonPointerISA(isa, real_isa) == false)
return ObjCLanguageRuntime::ClassDescriptorSP();
auto cache_iter = m_cache.find(real_isa);
if (cache_iter != m_cache.end())
return cache_iter->second;
auto descriptor_sp =
m_runtime.ObjCLanguageRuntime::GetClassDescriptorFromISA(real_isa);
if (descriptor_sp) // cache only positive matches since the table might grow
m_cache[real_isa] = descriptor_sp;
return descriptor_sp;
}
bool AppleObjCRuntimeV2::NonPointerISACache::EvaluateNonPointerISA(
ObjCISA isa, ObjCISA &ret_isa) {
if ((isa & ~m_objc_debug_isa_class_mask) == 0)
return false;
if ((isa & m_objc_debug_isa_magic_mask) == m_objc_debug_isa_magic_value) {
ret_isa = isa & m_objc_debug_isa_class_mask;
return (ret_isa != 0); // this is a pointer so 0 is not a valid value
}
return false;
}
ObjCLanguageRuntime::EncodingToTypeSP AppleObjCRuntimeV2::GetEncodingToType() {
if (!m_encoding_to_type_sp)
m_encoding_to_type_sp.reset(new AppleObjCTypeEncodingParser(*this));
return m_encoding_to_type_sp;
}
lldb_private::AppleObjCRuntime::ObjCISA
AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) {
ObjCISA ret = isa;
if (m_non_pointer_isa_cache_ap)
m_non_pointer_isa_cache_ap->EvaluateNonPointerISA(isa, ret);
return ret;
}
bool AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded() {
if (m_CFBoolean_values)
return true;
static ConstString g_kCFBooleanFalse("kCFBooleanFalse");
static ConstString g_kCFBooleanTrue("kCFBooleanTrue");
std::function<lldb::addr_t(ConstString)> get_symbol =
[this](ConstString sym) -> lldb::addr_t {
SymbolContextList sc_list;
if (GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
g_kCFBooleanFalse, lldb::eSymbolTypeData, sc_list) == 1) {
SymbolContext sc;
sc_list.GetContextAtIndex(0, sc);
if (sc.symbol)
return sc.symbol->GetLoadAddress(&GetProcess()->GetTarget());
}
return LLDB_INVALID_ADDRESS;
};
lldb::addr_t false_addr = get_symbol(g_kCFBooleanFalse);
lldb::addr_t true_addr = get_symbol(g_kCFBooleanTrue);
return (m_CFBoolean_values = {false_addr, true_addr}).operator bool();
}
void AppleObjCRuntimeV2::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
lldb::addr_t &cf_false) {
if (GetCFBooleanValuesIfNeeded()) {
cf_true = m_CFBoolean_values->second;
cf_false = m_CFBoolean_values->first;
} else
this->AppleObjCRuntime::GetValuesForGlobalCFBooleans(cf_true, cf_false);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.