// Scan a single chromosome with interactive covariates
// this version uses less memory but will be slower
// (since we need to work with each position, one at a time)
// and this one allows weights for the individuals (the same for all phenotypes)
//
// genoprobs = 3d array of genotype probabilities (individuals x genotypes x positions)
// pheno = matrix of numeric phenotypes (individuals x phenotypes)
// (no missing data allowed)
// addcovar = additive covariates (an intercept, at least)
// intcovar = interactive covariates (should also be included in addcovar)
// weights = vector of weights
//
// output = matrix of residual sums of squares (RSS) (phenotypes x positions)
//
// [[Rcpp::export]]
NumericMatrix scan_binary_onechr_intcovar_weighted_lowmem(const NumericVector& genoprobs,
const NumericMatrix& pheno,
const NumericMatrix& addcovar,
const NumericMatrix& intcovar,
const NumericVector& weights,
const int maxit=100,
const double tol=1e-6,
const double qr_tol=1e-12,
const double eta_max=30.0)
{
const int n_ind = pheno.rows();
if(Rf_isNull(genoprobs.attr("dim")))
throw std::invalid_argument("genoprobs should be a 3d array but has no dim attribute");
const Dimension d = genoprobs.attr("dim");
if(d.size() != 3)
throw std::invalid_argument("genoprobs should be a 3d array");
const int n_pos = d[2];
const int n_phe = pheno.cols();
if(n_ind != d[0])
throw std::range_error("nrow(pheno) != nrow(genoprobs)");
if(n_ind != addcovar.rows())
throw std::range_error("nrow(pheno) != nrow(addcovar)");
if(n_ind != intcovar.rows())
throw std::range_error("nrow(pheno) != nrow(intcovar)");
NumericMatrix result(n_phe, n_pos);
for(int pos=0; pos<n_pos; pos++) {
Rcpp::checkUserInterrupt(); // check for ^C from user
// form X matrix
NumericMatrix X = formX_intcovar(genoprobs, addcovar, intcovar, pos, true);
for(int phe=0; phe<n_phe; phe++) {
// do regression
result(phe,pos) = calc_ll_binreg_weighted(X, pheno(_,phe), weights, maxit, tol, qr_tol, eta_max);
}
}
return result;
}
void IteratorBase::copyDatabaseData(PointBuffer& source,
PointBuffer& destination,
Dimension const& dest_dim,
boost::uint32_t source_starting_position,
boost::uint32_t destination_starting_position,
boost::uint32_t howMany)
{
boost::optional<Dimension const&> source_dim = source.getSchema().getDimensionOptional(dest_dim.getName());
if (!source_dim)
{
return;
}
for (boost::uint32_t i = 0; i < howMany; ++i)
{
if (dest_dim.getInterpretation() == source_dim->getInterpretation() &&
dest_dim.getByteSize() == source_dim->getByteSize() &&
pdal::Utils::compare_distance(dest_dim.getNumericScale(), source_dim->getNumericScale()) &&
pdal::Utils::compare_distance(dest_dim.getNumericOffset(), source_dim->getNumericOffset()) &&
dest_dim.getEndianness() == source_dim->getEndianness()
)
{
// FIXME: This test could produce false positives
boost::uint8_t* source_position = source.getData(source_starting_position+i) + source_dim->getByteOffset();
boost::uint8_t* destination_position = destination.getData(destination_starting_position + i) + dest_dim.getByteOffset();
memcpy(destination_position, source_position, source_dim->getByteSize());
}
else
{
PointBuffer::scaleData(source,
destination,
*source_dim,
dest_dim,
source_starting_position + i,
destination_starting_position + i);
}
}
}
//add dimension into cube if add success return true else return false
bool XCube::addDimension(const Dimension& dimension)
{
if(this->getDimension(dimension.getName()))
{
Dimension *tmpdimension=new Dimension;
*tmpdimension=dimension;
tmpdimension->setCubeDimension(this);
this->_dimensions.push_back(tmpdimension);
return true;
}
return false;
}
static Dimension fillInDimension(const Dimension& newSize, const Dimension& inputSize)
{
if(newSize.product() == inputSize.product())
{
return newSize;
}
Dimension size(newSize);
// fill in remaining non-empty dimensions
size_t remaining = inputSize.product() / size.product();
size_t dimension = size.size();
assert(inputSize.product() % size.product() == 0);
// TODO: be smarter about the remainder
for(size_t d = dimension; d < inputSize.size(); ++d)
{
if(remaining <= 1)
{
break;
}
size.push_back(remaining);
remaining /= remaining;
}
assert(size.product() == inputSize.product());
return size;
}
void GuiCompleter::asyncUpdatePopup()
{
Cursor cur = gui_->bufferView().cursor();
if (!cur.inset().completionSupported(cur)
|| !cur.bv().paragraphVisible(cur)) {
popupVisible_ = false;
return;
}
// get dimensions of completion prefix
Dimension dim;
int x;
int y;
cur.inset().completionPosAndDim(cur, x, y, dim);
// and calculate the rect of the popup
QRect rect;
if (popup()->layoutDirection() == Qt::RightToLeft)
rect = QRect(x + dim.width() - 200, y - dim.ascent() - 3, 200, dim.height() + 6);
else
rect = QRect(x, y - dim.ascent() - 3, 200, dim.height() + 6);
// Resize the columns in the popup.
// This should really be in the constructor. But somehow the treeview
// has a bad memory about it and we have to tell him again and again.
QTreeView * listView = static_cast<QTreeView *>(popup());
listView->header()->setStretchLastSection(false);
listView->header()->setResizeMode(0, QHeaderView::Stretch);
listView->header()->setResizeMode(1, QHeaderView::Fixed);
listView->header()->resizeSection(1, 22);
// show/update popup
complete(rect);
}
bool Schema::setDimension(Dimension const& dim)
{
// Try setting based on UUID first if it's there and not null.
if (dim.getUUID() != boost::uuids::nil_uuid())
{
schema::index_by_uid& id_index = m_index.get<schema::uid>();
schema::index_by_uid::const_iterator id = id_index.find(dim.getUUID());
if (id != id_index.end())
{
id_index.replace(id, dim);
return true;
}
}
schema::index_by_name& name_index = m_index.get<schema::name>();
schema::index_by_name::iterator it = name_index.find(dim.getName());
// FIXME: If there are two dimensions with the same name here, we're
// screwed if they both have the same namespace too
if (it != name_index.end())
{
while (it != name_index.end())
{
if (boost::equals(dim.getNamespace(), it->getNamespace()))
{
name_index.replace(it, dim);
return true;
}
++it;
}
}
else
{
std::ostringstream oss;
oss << "Dimension with name '" << dim.getName() << "' not found, unable to Schema::setDimension";
throw dimension_not_found(oss.str());
}
return true;
}
unsigned PuzzleWindow::getNumberofMisplacedTile(Board testBoard, Board goalBoard)
{
Dimension theDimension;
theDimension = testBoard.getDimension();
unsigned ROWS = theDimension.getRow();
unsigned COLS = theDimension.getCol();
unsigned start = 1;
unsigned counter =0;
for(unsigned i = 0;i < ROWS;++i)
{
for(unsigned j = 0;j < COLS;++j)
{
//if(start != testBoard[i][j].getNumber())
{
counter++;
}
start++;
}
}
return counter;
}
NUMLDocument* createExample52()
{
NUMLDocument* doc = new NUMLDocument();
ResultComponent* r = doc->createResultComponent();
r->setId("main_fitting_result");
DimensionDescription* d = r->getDimensionDescription();
TupleDescription* t = d->createTupleDescription();
t->setName("Main");
AtomicDescription* a = t->createAtomicDescription();
a->setName( "Objective Value");
a->setValueType("float");
a = t->createAtomicDescription();
a->setName( "Root Mean Square");
a->setValueType("float");
a = t->createAtomicDescription();
a->setName( "Standard Deviation");
a->setValueType("float");
Dimension* dim = r->getDimension();
Tuple* tuple = dim->createTuple();
AtomicValue* val = tuple->createAtomicValue();
val->setValue("12.5015");
val = tuple->createAtomicValue();
val->setValue("0.158123");
val = tuple->createAtomicValue();
val->setValue("0.159242");
return doc;
}
bool NewMapState::handleEvent(StiGame::EventThrower *src, StiGame::EventArgs *evt)
{
if(src == &btnBack)
{
running = false;
MapEditMainMenu *state = new MapEditMainMenu();
viewport->push(state);
return true;
}
else if(src == &btnCreate)
{
running = false;
Dimension *mapSize = (dynamic_cast<MapSizeVO*>(listSizes.getSelectedItem()))->getDimension();
//STRData::MapData *mp = new STRData::MapData(mapSize->getWidth(), mapSize->getHeight());
//todo
MEMap *map = new MEMap(mapSize->getWidth(), mapSize->getHeight());
MapEditState *state = new MapEditState(map);
viewport->push(state);
return true;
}
}
std::string Compressor::Compress(Point &point, Dimension &dimension) const {
assert((dimension.num_rows >= 1) && (dimension.num_columns >= 1));
if ((dimension.num_rows == 1) && (dimension.num_columns == 1)) {
return data_.Get(point);
}
std::string res;
auto top_left_dim = dimension.TopLeft();
res += Compress(point, top_left_dim);
if (dimension.num_columns > 1) {
auto top_right_begin = ComputeTopRight(point, top_left_dim);
auto top_right_dim = dimension.TopRight();
res += Compress(top_right_begin, top_right_dim);
}
if (dimension.num_rows > 1) {
auto bottom_left_begin = ComputeBottomLeft(point, top_left_dim);
auto bottom_left_dim = dimension.BottomLeft();
res += Compress(bottom_left_begin, bottom_left_dim);
}
if ((dimension.num_columns > 1) && (dimension.num_rows > 1)) {
auto bottom_right_begin = ComputeBottomRight(point, top_left_dim);
auto bottom_right_dim = dimension.BottomRight();
res += Compress(bottom_right_begin, bottom_right_dim);
}
if (AllSame(res)) {
char data[2]{res[0], '\0'};
return std::string(data);
}
return "D" + res;
}
BoxT
makePlaneAroundDimensionEnd(
const Dimension<T>& dim,
const typename Dimension<T>::End end) const
{
double inf = std::numeric_limits<double>::infinity();
Vector<DIM, T> lower(-inf), upper(inf);
lower[dim.direction()] = dim(end);
upper[dim.direction()] = dim(end);
// now convert them
PointT minimum = VectorOps<DIM, T>::toBoostPoint(
lower);
PointT maximum = VectorOps<DIM, T>::toBoostPoint(
upper);
return BoxT(minimum, maximum);
}
size_t Dimension::evalpos (const Dimension & d) const
{
size_t n= size ();
if (d.size () != n)
throw ErrBadSubscript;
size_t pos= d [0];
if (pos > dim [0])
throw ErrBadSubscript;
for (size_t i= 1; i < n; ++i)
{
if (d [i] > dim [i] )
throw ErrBadSubscript;
pos*= dim [i] + 1;
pos+= d [i];
}
return pos;
}
void InsetMathBinom::metrics(MetricsInfo & mi, Dimension & dim) const
{
Dimension dim0, dim1;
// FIXME: for an unknown reason the cells must be set directly
// after the StyleChanger and cannot be set after the if case
if (kind_ == DBINOM) {
StyleChanger dummy(mi.base, LM_ST_DISPLAY);
cell(0).metrics(mi, dim0);
cell(1).metrics(mi, dim1);
} else if (kind_ == TBINOM) {
StyleChanger dummy(mi.base, LM_ST_SCRIPT);
cell(0).metrics(mi, dim0);
cell(1).metrics(mi, dim1);
} else {
FracChanger dummy(mi.base);
cell(0).metrics(mi, dim0);
cell(1).metrics(mi, dim1);
}
dim.asc = dim0.height() + 4 + 5;
dim.des = dim1.height() + 4 - 5;
dim.wid = max(dim0.wid, dim1.wid) + 2 * dw(dim.height()) + 4;
metricsMarkers2(dim);
}
Dimension UnitSystem::parse(const std::string& dimension) const {
const size_t divCount = std::count( dimension.begin() , dimension.end() , '/' );
if( divCount > 1 )
throw std::invalid_argument("Dimension string can only have one division sign '/'");
const bool haveDivisor = divCount == 1;
if( !haveDivisor ) return parseFactor( dimension );
std::vector<std::string> parts;
boost::split(parts , dimension , boost::is_any_of("/"));
Dimension dividend = parseFactor( parts[0] );
Dimension divisor = parseFactor( parts[1] );
if (dividend.getSIOffset() != 0.0 || divisor.getSIOffset() != 0.0)
throw std::invalid_argument("Composite dimensions cannot currently require a conversion offset");
return Dimension::newComposite( dimension, dividend.getSIScaling() / divisor.getSIScaling() );
}
template<class Type> bool Dimension<Type>::operator >=(Dimension<Type> dim){
return (dimension >= dim.getDimension());
}
LIBSBML_CPP_NAMESPACE_USE
int
main (int argc, char* argv[])
{
SBMLNamespaces sbmlns(3,1,"arrays",1);
// create the document
SBMLDocument *document = new SBMLDocument(&sbmlns);
// set the required attribute to true
ArraysSBMLDocumentPlugin * docPlug =
static_cast<ArraysSBMLDocumentPlugin*>(document->getPlugin("arrays"));
docPlug->setRequired(true);
// create the Model
Model* model=document->createModel();
// create the parameters
// first parameter - for dimension m
Parameter * p = model->createParameter();
p->setId("m");
p->setConstant(true);
p->setValue(2);
// second parameter - for dimension n
p = model->createParameter();
p->setId("n");
p->setConstant(true);
p->setValue(1);
// third parameter - 2 x 1 matrix of parameters
p = model->createParameter();
p->setId("x");
p->setConstant(false);
// create the Dimensions via the Plugin
ArraysSBasePlugin * arraysPlug =
static_cast<ArraysSBasePlugin*>(p->getPlugin("arrays"));
// first dimension
Dimension * dim = arraysPlug->createDimension();
dim->setArrayDimension(0);
dim->setSize("m");
// second dimension
dim = arraysPlug->createDimension();
dim->setArrayDimension(1);
dim->setSize("n");
// other parameters
p = model->createParameter();
p->setId("y");
p->setConstant(true);
p->setValue(2.3);
// create the initialAssignment
InitialAssignment *ia = model->createInitialAssignment();
ia->setSymbol("x");
ASTNode * row1 = new ASTNode(AST_LINEAR_ALGEBRA_VECTOR_CONSTRUCTOR);
ASTNode * ci1 = new ASTNode(AST_NAME);
ci1->setName("y");
row1->addChild(ci1);
ASTNode * row2 = new ASTNode(AST_LINEAR_ALGEBRA_VECTOR_CONSTRUCTOR);
ASTNode * ci2 = new ASTNode(AST_INTEGER);
ci2->setValue(2);
row2->addChild(ci2);
ASTNode * math = new ASTNode(AST_LINEAR_ALGEBRA_VECTOR_CONSTRUCTOR);
math->addChild(row1);
math->addChild(row2);
ia->setMath(math);
writeSBML(document,"arrays_example3.xml");
delete document;
return 0;
}
/*************************************************************
* another kind of function that return a set
************************************************************/
std::vector<QueryTuple*> SetFunFactory::funInstance(XSchema* _pSch,
std::string& _cubeName,
SetTypesec _typesec,
std::vector<std::string>& theVector)
{
int size = theVector.size();
XCube* pCube = _pSch->getCube(_cubeName);
vector<QueryMember*> QmemVector;
vector<QueryTuple*> QtupleVector;
switch(_typesec)
{
//函数Members的处理对象
//对于[Time].[Time].[1995].[Q1].[Month].Members
//theVector中应依次存有string：Time, Time, 1995, Q1, Month
case Members:
if (size == 0 )
{
cout<<"error! please input query information..."<<endl;
}
else if (size == 1) //由于现在还不支持多个Hierarchy，所以size 为1、2结果是一样的
{
if ((theVector.at(0) == "Measures")||(theVector.at(0) == "measures"))
{
//元数据现在还没有支持默认度量，先以第一个度量为默认的
vector<Measure*> vecMea = pCube->getMeasures();
vector<Measure*>::iterator meaIterator;
if (!vecMea.empty())
{
for (meaIterator = vecMea.begin(); meaIterator < vecMea.end(); meaIterator++)
{
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setHierarchyName("Measures");
pMem->setLevelName("Measures");
pMem->setVal((*meaIterator)->getName());
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
}
return QtupleVector;
}
else
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
if (!pDim)
{
cout<<"error! wrong dimension name...."<<endl;
}
else
{
//是取默认Hierarchy
//获得的QueryMember应该是最细粒度的所有的QueryMember
//所以在这里要作笛卡儿积（并不算纯粹的笛卡儿积），见for循环
vector< Hierarchy* > hieVector = pDim->getHierarchies();
Hierarchy* pHie = hieVector.at(0);//取第一个为默认Hierarchy
//首先把Member从数据库中load出来
pHie->LoadMembers();
string hierarcyName = pHie->getName();
vector<string> vecLevelName;
vector< vector<string> > memNameInLevels;//用于存储每个Level上成员名字的vector
vector<Level*> vecLevel = pHie->getLeveles();
int levelSize = vecLevel.size();
Level* pLevel = vecLevel.at(levelSize-1);
string levelName = pLevel->getName();
vector<Member*> vecMem = pLevel->getMembers();
vector<Member*>::iterator memIterator;
for (memIterator = vecMem.begin(); memIterator < vecMem.end(); memIterator++)
{
string memberVal = (*memIterator)->getKey();
vector<string> vecAncestorVal;
vector<string> vecAncestorLevel;
vector<Member*> vecParentMems;
vector<Member*>::iterator pMemIterator;
vecParentMems = (*memIterator)->getAllParents();
for (pMemIterator = vecParentMems.begin(); pMemIterator < vecParentMems.end(); pMemIterator++)
{
string parentVal = (*pMemIterator)->getKey();
Level* pLevel = (*pMemIterator)->getLevel();
string parentLevel = pLevel->getName();
vecAncestorVal.push_back(parentVal);
vecAncestorLevel.push_back(parentLevel);
}
std::auto_ptr<QueryMember>p(new QueryMember);
p->setHierarchyName(hierarcyName);
p->setAncestorVals(vecAncestorVal);
p->setAncestorLevels(vecAncestorLevel);
p->setVal(memberVal);
p->setLevelName(levelName);
QmemVector.push_back(p.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
}
}
else if (size == 2)
{
string dimName = theVector.at(0);
Dimension* pDim = pCube->getDimension(dimName);
if (pDim == NULL)
{
cout<<"null point to dimension"<<endl;
}
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
if (pHie == NULL)
{
cout<<"null point to Hierarchy"<<endl;
}
//首先把Member从数据库中load出来
pHie->LoadMembers();
string hierarcyName = pHie->getName();
vector<string> vecLevelName;
vector< vector<string> > memNameInLevels;//用于存储每个Level上成员名字的vector
vector<Level*> vecLevel = pHie->getLeveles();
int levelSize = vecLevel.size();
Level* pLevel = vecLevel.at(levelSize-1);
string levelName = pLevel->getName();
vector<Member*> vecMem = pLevel->getMembers();
vector<Member*>::iterator memIterator;
for (memIterator = vecMem.begin(); memIterator < vecMem.end(); memIterator++)
{
string memberVal = (*memIterator)->getKey();
vector<string> vecAncestorVal;
vector<string> vecAncestorLevel;
vector<Member*> vecParentMems;
vector<Member*>::iterator pMemIterator;
vecParentMems = (*memIterator)->getAllParents();
for (pMemIterator = vecParentMems.begin(); pMemIterator < vecParentMems.end(); pMemIterator++)
{
string parentVal = (*pMemIterator)->getKey();
Level* pLevel = (*pMemIterator)->getLevel();
string parentLevel = pLevel->getName();
vecAncestorVal.push_back(parentVal);
vecAncestorLevel.push_back(parentLevel);
}
std::auto_ptr<QueryMember>p(new QueryMember);
p->setHierarchyName(hierarcyName);
p->setAncestorVals(vecAncestorVal);
p->setAncestorLevels(vecAncestorLevel);
p->setVal(memberVal);
p->setLevelName(levelName);
QmemVector.push_back(p.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else if(size == 3)
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
//首先把Member从数据库中load出来
pHie->LoadMembers();
Level* pLevel = pHie->getLevel(theVector.at(2));
vector<Member*> memVector1;
memVector1 = pLevel->getMembers();
if (memVector1.empty())
{
cout<<"empty member vector,do not get the members from database"<<endl;
}
else{
vector<Member*>::iterator theIterator;
for (theIterator = memVector1.begin(); theIterator < memVector1.end(); theIterator++)
{
if (*theIterator == NULL)
{
cout<<"do not get the members from the database!"<<endl;
}
string QueryMemberVal = (*theIterator)->getKey();
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal(QueryMemberVal);
pMem->setLevelName(theVector.at(2));
pMem->setHierarchyName(theVector.at(1));
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
}
else//出现成员等于或多于一个的情况 eg. [Time].[Time].[1995].[Q1].[Month].Members
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
//首先把Member从数据库中load出来
pHie->LoadMembers();
Level* pLevel = pHie->getLevel(theVector.at(size-1));
vector<Member*> memVector = pLevel->getMembers();
vector<Member*>::iterator theIterator;
for (theIterator = memVector.begin(); theIterator < memVector.end(); theIterator++)
{
string QueryMemberVal = (*theIterator)->getKey();
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal(QueryMemberVal);
pMem->setLevelName(theVector.at(size));
pMem->setHierarchyName(theVector.at(1));
vector<string> ancestorVals;
vector<string> ancestorLevles;
for (int i = 2; i < size-1; i++)
{
vector<Level*> levelVec;
levelVec = pHie->getLeveles();
ancestorVals.push_back(theVector.at(i));
Level* p = levelVec.at(i);
ancestorLevles.push_back(p->getName());
}
pMem->setAncestorVals(ancestorVals);
pMem->setAncestorLevels(ancestorLevles);
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
break;
//函数AllMembers,参考SQL Server联机丛书
//返回包含指定维度或级别的所有成员的集合，包括计算成员。
//注：暂时不考虑计算成员的处理,此时功能和Members功能差不多
case AllMembers:
if (size == 0 )
{
cout<<"error! please input the query information!"<<endl;
}
else if (size == 1)
{
//取得默认Hierarchy
//暂时只支持一个Hierarchy，即和维度名相同
string dimensionName = theVector.at(0);
string hierarchyName = dimensionName;
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal("All");
pMem->setHierarchyName(hierarchyName);
pMem->setLevelName("All");
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
return QtupleVector;
}
else if(size == 2)//[Time].[Time].AllMembers
{
string dimensionName = theVector.at(0);
Dimension* pDim = pCube->getDimension(dimensionName);
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setHierarchyName(pHie->getName());
pMem->setLevelName("All");
pMem->setVal("All");
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
return QtupleVector;
}
else //[Time].[Time].[Year].AllMembers
{
Dimension* pDim = pCube->getDimension(theVector.at(0));
Hierarchy* pHie = pDim->getHierarchy(theVector.at(1));
Level* pLevel = pHie->getLevel(theVector.at(size-1));
vector<Member*> memVector = pLevel->getMembers();
vector<Member*>::iterator theIterator;
for (theIterator = memVector.begin(); theIterator < memVector.end(); theIterator++)
{
string QueryMemberVal = (*theIterator)->getKey();
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal(QueryMemberVal);
pMem->setLevelName(theVector.at(size));
pMem->setHierarchyName(theVector.at(1));
vector<string> ancestorVals;
vector<string> ancestorLevles;
for (int i = 2; i < size-1; i++)
{
vector<Level*> levelVec;
levelVec = pHie->getLeveles();
ancestorVals.push_back(theVector.at(i));
Level* p = levelVec.at(i);
ancestorLevles.push_back(p->getName());
}
pMem->setAncestorVals(ancestorVals);
pMem->setAncestorLevels(ancestorLevles);
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
//pHie->CleanMembers();没有加载过member
return QtupleVector;
}
break;
case Children:
//注：JPivot里面是不可能出现这种情况的
//因为一旦出现，JPivot会自动转化成加一个CurrentMember函数
//如：[Time].Children会自动转变成[Time].CurrentMember.Children
string dimName = "";
string hieName = "";
bool isall = false;
if (size == 1)
{
cout<<"error! invalid using of Children"<<endl;
}
else if(size == 2)
{
Dimension* pDim =NULL;
Hierarchy* pHie = NULL;
if (isDimHie(theVector.at(0)))
{
vector<string> temp = distinct(theVector.at(0));
dimName = temp.at(0);
pDim = pCube->getDimension(dimName);
assert(pDim);
hieName = temp.at(1);
Hierarchy* pHie = pDim->getHierarchy(hieName);
assert(pHie);
}
else
{
dimName = theVector.at(0);
pDim = pCube->getDimension(theVector.at(0));
assert(pDim);
pHie = pDim->getDefaultHierarchy();
hieName = pHie->getName();
assert(pHie);
}
assert(pHie);
pHie->LoadMembers();
vector<Level*> levelVec = pHie->getLeveles();
Level* pLevel1 = levelVec.at(0);//父member所在的level
assert(pLevel1);
string ancestorVal = theVector.at(1);
string ancestorLevel = pLevel1->getName();
vector<string> valVec;
vector<string> theVec;
valVec.push_back(ancestorVal);
theVec.push_back(ancestorLevel);
Level* pLevel2 = levelVec.at(1);//查询的member所在的level
string QueryMemberLevel = pLevel2->getName();
// cout<<"value:"<<theVector.at(1)<<endl;
Member* pm = pLevel1->getMember(theVector.at(1),NULL);////////////////////////////////
vector<Member*> memVec = pm->getChildrenMember();
//cout<<QueryMemberLevel<<" "<<memVec.size()<<endl;
vector<Member*>::iterator memIterator;
for (memIterator = memVec.begin(); memIterator < memVec.end(); memIterator++)
{
string QueryMemberVal = (*memIterator)->getKey();
std::auto_ptr<QueryMember>p(new QueryMember(dimName,hieName,QueryMemberLevel,QueryMemberVal,valVec,theVec,isall));
QmemVector.push_back(p.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else if (size >= 2)
{
Dimension* pDim = NULL;
Hierarchy* pHie = NULL;
if (isDimHie(theVector.at(0)))
{
vector<string> temp = distinct(theVector.at(0));
dimName = temp.at(0);
pDim = pCube->getDimension(temp.at(0));
assert(pDim);
hieName = temp.at(1);
pHie = pDim->getHierarchy(temp.at(1));
assert(pHie);
}
else
{
dimName = theVector.at(0);
pDim = pCube->getDimension(theVector.at(0));
assert(pDim);
pHie = pDim->getDefaultHierarchy();
}
assert(pHie);
string hieName = pHie->getName();
pHie->LoadMembers();
vector<Level*> levelVec = pHie->getLeveles();
//children members'level
Level* pLevel = levelVec.at(size-1);
vector<Level*> parentLevels;
vector<Level*>::iterator levelIterator;
parentLevels.assign(levelVec.begin(),levelVec.begin()+size-1);
vector<string> ancestorVal;
vector<string> ancestorLevel;
for (int i = 1; i < size; i++)
{
ancestorVal.push_back(theVector.at(i));
}
for (levelIterator = parentLevels.begin(); levelIterator < parentLevels.end(); levelIterator++)
{
string ancestorLevelName = (*levelIterator)->getName();
ancestorLevel.push_back(ancestorLevelName);
}
string firstparentMemVal = theVector.at(1);
Member* firstparentMem = parentLevels.at(0)->getMember(firstparentMemVal, NULL);
Member* lastParentMem = NULL;
if (size == 2)
{
assert(firstparentMem);
lastParentMem = firstparentMem;
}
else
{
for(int n = 2; n < size; n++)
{
//cout<<"theVector.at(n)"<<theVector.at(n)<<endl;
firstparentMem = parentLevels.at(n-1)->getMember(theVector.at(n), firstparentMem);
assert(firstparentMem);
}
}
lastParentMem = firstparentMem;
assert(lastParentMem);
vector<Member*> memVec = lastParentMem->getChildrenMember();
vector<Member*>::iterator memIterator;
for (memIterator = memVec.begin(); memIterator < memVec.end(); memIterator++)
{
string QueryMemberVal = (*memIterator)->getKey();
std::auto_ptr<QueryMember>ptr(new QueryMember);
ptr->setVal(QueryMemberVal);
ptr->setLevelName(pLevel->getName());
ptr->setHierarchyName(hieName);
ptr->setDimensionName(dimName);
ptr->setAncestorVals(ancestorVal);
ptr->setAncestorLevels(ancestorLevel);
ptr->setIsAll(isall);
QmemVector.push_back(ptr.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
break;
//下一个函数起点
}
}
void CustomServerNetworkHandler::handleLogin(ServerNetworkHandler *real, const RakNet::RakNetGUID &guid, LoginPacket *packet)
{
if (!real->visible || real->_getPlayer(guid))
return;
if (packet->protocol1 != SharedConstants::NetworkProtocolVersion)
{
PlayStatusPacket statusPacket;
if (packet->protocol1 < SharedConstants::NetworkProtocolVersion)
statusPacket.status = PlayStatusPacket::LOGIN_FAILED_CLIENT;
else
statusPacket.status = PlayStatusPacket::LOGIN_FAILED_SERVER;
real->sender->send(guid, statusPacket);
return;
}
std::string username = packet->username;
const char *ipAddress = real->raknet->getPeer()->GetSystemAddressFromGuid(guid).ToString(false);
PlayerPreLoginEvent preLoginEvent(username, ipAddress, packet->clientUUID);
ServerManager::getPluginManager()->callEvent(preLoginEvent);
if (preLoginEvent.getResult() != PlayerPreLoginEvent::ALLOWED)
{
disconnectClient(real, guid, preLoginEvent.getKickMessage());
return;
}
bool valid = true;
int len = username.length();
if (len > 16 || len < 3)
valid = false;
for (int i = 0; i < len; i++)
{
char c = username[i];
if ((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') || c == '_')
continue;
valid = false;
break;
}
std::unique_ptr<ServerPlayer> serverPlayer = real->createNewPlayer(guid, packet);
SMPlayer *smPlayer = new SMPlayer(ServerManager::getServer(), serverPlayer.get());
PlayerLoginEvent loginEvent(smPlayer, ipAddress);
std::string iusername = SMUtil::toLower(packet->username);
if (!valid || !iusername.compare(SMUtil::toLower(ServerManager::getLocalPlayer()->getName())) ||
!iusername.compare("rcon") || !iusername.compare("console") || !iusername.compare("server"))
loginEvent.disallow(PlayerLoginEvent::KICK_INVALID_NAME, "disconnectionScreen.invalidName");
else if (packet->skin.length() != 64 * 32 * 4 && packet->skin.length() != 64 * 64 * 4)
loginEvent.disallow(PlayerLoginEvent::KICK_INVALID_SKIN, "disconnectionScreen.invalidSkin");
else if (ServerManager::getBanList(BanList::NAME)->isBanned(iusername))
{
BanEntry *entry = ServerManager::getBanList(BanList::NAME)->getBanEntry(iusername);
loginEvent.disallow(PlayerLoginEvent::KICK_BANNED, "You are banned from this server! Reason: " + entry->getReason());
}
else if (ServerManager::hasWhitelist() && !ServerManager::isWhitelisted(iusername))
loginEvent.disallow(PlayerLoginEvent::KICK_WHITELIST, "You are not white-listed on this server!");
else if (ServerManager::getBanList(BanList::IP)->isBanned(ipAddress))
{
BanEntry *entry = ServerManager::getBanList(BanList::IP)->getBanEntry(ipAddress);
loginEvent.disallow(PlayerLoginEvent::KICK_BANNED, "Your IP address is banned from this server! Reason: " + entry->getReason());
}
ServerManager::getPluginManager()->callEvent(loginEvent);
if (loginEvent.getResult() != PlayerLoginEvent::ALLOWED)
{
disconnectClient(real, guid, loginEvent.getKickMessage());
delete smPlayer;
return;
}
std::vector<SMPlayer *> players = ServerManager::getOnlinePlayers();
for (int i = 0; i < players.size(); ++i)
{
SMPlayer *p = players[i];
if (!SMUtil::toLower(p->getName()).compare(iusername))
{
disconnectClient(real, p->getHandle()->guid, "You logged in from another location");
break;
}
}
PlayStatusPacket pk;
pk.status = PlayStatusPacket::LOGIN_SUCCESS;
real->sender->send(guid, pk);
Dimension *dimension = serverPlayer->getDimension();
if (!dimension)
dimension = real->level->createDimension(DIMENSION_NORMAL);
serverPlayer->prepareRegion(*dimension->getChunkSource());
real->_sendLevelData(serverPlayer.get(), guid);
ServerPlayer *player = serverPlayer.get();
real->level->addPlayer(std::move(serverPlayer));
real->_sendAdditionalLevelData(player, guid);
ServerManager::getServer()->addPlayer(smPlayer);
real->raknet->announceServer(ServerManager::getServerName());
smPlayer->setAddress(real->raknet->getPeer()->GetSystemAddressFromGuid(guid).ToString(false));
PlayerJoinEvent joinEvent(smPlayer, "");
ServerManager::getPluginManager()->callEvent(joinEvent);
}
bool InterpreterHelper::getTransformation(std::string & line, AbstractPrimitive * prim,Dimension & temp){
if(startsWith(line,".rot")){ ///rotation
line = eraseFirst(line,4);
if(line.at(0) != '('){ ////only one arg?
std::string temp;
char t = line.at(0);
line = eraseFirst(line,2);
temp=extractUntil(line,')',')');
if(!temp.length()) return false;
line = eraseFirst(line,temp.length()+1); ////+ 1 bo ')'
switch(t){
case 'x' :
prim->getRotation().X = atof(temp.data()); break;
case 'y' :
prim->getRotation().Y = atof(temp.data()); break;
case 'z' :
prim->getRotation().Z = atof(temp.data()); break;
default : return false;
}
return true;
}else{
line = eraseFirst(line,1);
if(getArgs(line,temp)){
line = eraseFirst(line,1);
prim->getRotation() = temp;
return true;
}else
return false;
}
}
if(startsWith(line,".transl")){ ///translation
line = eraseFirst(line,7);
if(line.at(0) != '('){ ////only one arg?
std::string temp;
char t = line.at(0);
line = eraseFirst(line,2);
temp=extractUntil(line,')',')');
if(!temp.length()) return false;
switch(t){
case 'x' :
prim->getPosition().X = atof(temp.data()); break;
case 'y' :
prim->getPosition().Y = atof(temp.data()); break;
case 'z' :
prim->getPosition().Z = atof(temp.data()); break;
default : return false;
}
line = eraseFirst(line,temp.length()+1); ////+ 1 bo ')'
return true;
}else{
line = eraseFirst(line,1);
if(getArgs(line,temp)){
line = eraseFirst(line,1);
prim->getPosition() = temp;
return true;
}else
return false;
}
}
return false;
}
void Colorization::setScaledValue(PointBuffer& data,
double value,
Dimension const& d,
std::size_t pointIndex) const
{
float flt(0.0);
boost::int8_t i8(0);
boost::uint8_t u8(0);
boost::int16_t i16(0);
boost::uint16_t u16(0);
boost::int32_t i32(0);
boost::uint32_t u32(0);
boost::int64_t i64(0);
boost::uint64_t u64(0);
boost::uint32_t size = d.getByteSize();
switch (d.getInterpretation())
{
case dimension::Float:
if (size == 4)
{
flt = static_cast<float>(value);
data.setField<float>(d, pointIndex, flt);
}
if (size == 8)
{
data.setField<double>(d, pointIndex, value);
}
break;
case dimension::SignedInteger:
case dimension::SignedByte:
if (size == 1)
{
i8 = d.removeScaling<boost::int8_t>(value);
data.setField<boost::int8_t>(d, pointIndex, i8);
}
if (size == 2)
{
i16 = d.removeScaling<boost::int16_t>(value);
data.setField<boost::int16_t>(d, pointIndex, i16);
}
if (size == 4)
{
i32 = d.removeScaling<boost::int32_t>(value);
data.setField<boost::int32_t>(d, pointIndex, i32);
}
if (size == 8)
{
i64 = d.removeScaling<boost::int64_t>(value);
data.setField<boost::int64_t>(d, pointIndex, i64);
}
break;
case dimension::UnsignedInteger:
case dimension::UnsignedByte:
if (size == 1)
{
u8 = d.removeScaling<boost::uint8_t>(value);
data.setField<boost::uint8_t>(d, pointIndex, u8);
}
if (size == 2)
{
u16 = d.removeScaling<boost::uint16_t>(value);
data.setField<boost::uint16_t>(d, pointIndex, u16);
}
if (size == 4)
{
u32 = d.removeScaling<boost::uint32_t>(value);
data.setField<boost::uint32_t>(d, pointIndex, u32);
}
if (size == 8)
{
u64 = d.removeScaling<boost::uint64_t>(value);
data.setField<boost::uint64_t>(d, pointIndex, u64);
}
break;
case dimension::Pointer: // stored as 64 bits, even on a 32-bit box
case dimension::Undefined:
throw pdal_error("Dimension data type unable to be reprojected");
}
}
std::string PointBuffer::printDimension(Dimension const& dimension, boost::uint32_t index) const
{
boost::uint32_t const& size = dimension.getByteSize();
std::string output;
double scale = dimension.getNumericScale();
double offset = dimension.getNumericOffset();
bool applyScaling(false);
if (!Utils::compare_distance(scale, 1.0) ||
!Utils::compare_distance(offset, 0.0)
)
{
applyScaling = true;
}
switch (dimension.getInterpretation())
{
#define GETFIELDAS(T) getField<T>(dimension, index)
#define STRINGIFY(T,x) boost::lexical_cast<std::string>(boost::numeric_cast<T>(x))
// note we convert 8-bit fields to ints, so they aren't treated as chars
case dimension::SignedInteger:
if (size == 1)
{
if (!applyScaling)
output += STRINGIFY(boost::int32_t, GETFIELDAS(boost::int8_t));
else
{
boost::int8_t v = GETFIELDAS(boost::int8_t);
double d = dimension.applyScaling<boost::int8_t>(v);
output += STRINGIFY(double, d);
}
}
if (size == 2)
{
if (!applyScaling)
output += STRINGIFY(boost::int16_t, GETFIELDAS(boost::int16_t));
else
{
boost::int16_t v = GETFIELDAS(boost::int16_t);
double d = dimension.applyScaling<boost::int16_t>(v);
output += STRINGIFY(double, d);
}
}
if (size == 4)
{
if (!applyScaling)
output += STRINGIFY(boost::int32_t, GETFIELDAS(boost::int32_t));
else
{
boost::int32_t v = GETFIELDAS(boost::int32_t);
double d = dimension.applyScaling<boost::int32_t>(v);
output += STRINGIFY(double, d);
}
}
if (size == 8)
{
if (!applyScaling)
output += STRINGIFY(boost::int64_t, GETFIELDAS(boost::int64_t));
else
{
boost::int64_t v = GETFIELDAS(boost::int64_t);
double d = dimension.applyScaling<boost::int64_t>(v);
output += STRINGIFY(double, d);
}
}
break;
case dimension::UnsignedInteger:
if (size == 1)
{
if (!applyScaling)
output += STRINGIFY(boost::uint32_t, GETFIELDAS(boost::uint8_t));
else
{
boost::uint8_t v = GETFIELDAS(boost::uint8_t);
double d = dimension.applyScaling<boost::uint8_t>(v);
output += STRINGIFY(double, d);
}
}
if (size == 2)
{
if (!applyScaling)
output += STRINGIFY(boost::uint16_t, GETFIELDAS(boost::uint16_t));
else
{
boost::uint16_t v = GETFIELDAS(boost::uint16_t);
double d = dimension.applyScaling<boost::uint16_t>(v);
output += STRINGIFY(double, d);
}
}
if (size == 4)
{
if (!applyScaling)
output += STRINGIFY(boost::uint32_t, GETFIELDAS(boost::uint32_t));
else
{
boost::uint32_t v = GETFIELDAS(boost::uint32_t);
double d = dimension.applyScaling<boost::uint32_t>(v);
output += STRINGIFY(double, d);
}
}
if (size == 8)
{
if (!applyScaling)
output += STRINGIFY(double, GETFIELDAS(boost::uint64_t));
else
{
boost::uint64_t v = GETFIELDAS(boost::uint64_t);
double d = dimension.applyScaling<boost::uint64_t>(v);
output += STRINGIFY(double, d);
}
}
break;
case dimension::Float:
if (size == 4)
{
if (!applyScaling)
output += STRINGIFY(float, GETFIELDAS(float));
else
{
float v = GETFIELDAS(float);
double d = dimension.applyScaling<float>(v);
output += STRINGIFY(float, d);
}
}
bool XCube::writeXML(const std::string &outputfile)
{
DWXML xml;
xercesc::XercesDOMParser *m_DOMXmlParser1=xml.getDOMParser();
m_DOMXmlParser1->setValidationScheme( XercesDOMParser::Val_Auto );
m_DOMXmlParser1->setDoNamespaces( false );
m_DOMXmlParser1->setDoSchema( false );
m_DOMXmlParser1->setLoadExternalDTD( false );
XMLCh temp2[100];
XMLString::transcode("Core", temp2, 99);
DOMImplementation* impl2 = DOMImplementationRegistry::getDOMImplementation(temp2);
DOMDocument* doc = impl2->createDocument(
0, // root element namespace URI.
XMLString::transcode("Schema"), // root element name
0); // document type object (DTD).
if (impl2 != NULL)
{
try
{
DOMElement *cubeElem = doc->createElement(XMLString::transcode("Cube"));
if(this->_name != "")
cubeElem->setAttribute(XMLString::transcode("name"),XMLString::transcode(this->_name.c_str()));
if(this->_fact != "")
cubeElem->setAttribute(XMLString::transcode("tablename"),XMLString::transcode(this->_fact.c_str()));
if(this->_dimensions.size() > 0)
{
for(int i = 0; i < this->_dimensions.size(); i ++)
{
Dimension *tempDimension = this->getDimension(this->_dimensions[i]->getName());
cubeElem->appendChild(tempDimension->recursiveXML(doc));
}
}
XSchema *tempschema = this->getSchema();
DOMElement* schemaElem = doc->getDocumentElement();//create root
if(DataSource *tempDS = tempschema->getDataSource())
{
schemaElem -> appendChild(tempDS->recursiveXML(doc));
}
schemaElem -> appendChild(cubeElem);
}
catch (const OutOfMemoryException &)
{
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
return false;
}
catch (const DOMException& e)
{
XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;
return false;
}
catch (...)
{
XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl;
return false;
}
}
else
{return false;}
//use DOMwriter for export XML file
//Writer Ini
bool bRet = true;
XMLCh tempStr[100];
XMLString::transcode("LS", tempStr, 99);
DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr);
DOMWriter *m_pWriter = ((DOMImplementationLS*)impl)->createDOMWriter();
//set XML File in "UTF-8"
XMLCh *encoding = XMLString::transcode("UTF-8");
m_pWriter -> setEncoding(encoding);
// DOMDocument* m_pDoc;
const char * outfile = outputfile.c_str();
XMLFormatTarget* m_pFormatTarget = new LocalFileFormatTarget(outfile);
// construct the LocalFileFormatTarget
// m_pFormatTarget = new LocalFileFormatTarget(szPath);
// serialize a DOMNode to the local file "myXMLFile.xml"
//Write File in UTF-8
bRet = m_pWriter->writeNode(m_pFormatTarget, *doc);
if (bRet == false)
{
return false;
}
else
{
try
{
// optionally, you can flush the buffer to ensure all contents are written
m_pFormatTarget->flush();
delete m_pFormatTarget;
delete m_DOMXmlParser1;
delete m_pWriter;
doc->release();
XMLPlatformUtils::Terminate();
return true;
}
catch (const OutOfMemoryException&)
{
XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
return false;
}
catch (XMLException& e)
{
XERCES_STD_QUALIFIER cerr << "An error occurred during creation of output transcoder. Msg is:"
<< XERCES_STD_QUALIFIER endl
<< XMLString::transcode(e.getMessage()) << XERCES_STD_QUALIFIER endl;
return false;
}
}
}
void InsetMathFrac::draw(PainterInfo & pi, int x, int y) const
{
setPosCache(pi, x, y);
Dimension const dim = dimension(*pi.base.bv);
Dimension const dim0 = cell(0).dimension(*pi.base.bv);
if (kind_ == UNIT || (kind_ == UNITFRAC && nargs() == 3)) {
if (nargs() == 1) {
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
cell(0).draw(pi, x + 1, y);
} else if (nargs() == 2) {
cell(0).draw(pi, x + 1, y);
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
cell(1).draw(pi, x + dim0.width() + 5, y);
} else {
cell(2).draw(pi, x + 1, y);
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
FracChanger dummy(pi.base);
Dimension const dim1 = cell(1).dimension(*pi.base.bv);
Dimension const dim2 = cell(2).dimension(*pi.base.bv);
int xx = x + dim2.wid + 5;
cell(0).draw(pi, xx + 2,
y - dim0.des - 5);
cell(1).draw(pi, xx + dim0.width() + 5,
y + dim1.asc / 2);
}
} else {
FracChanger dummy(pi.base);
Dimension const dim1 = cell(1).dimension(*pi.base.bv);
int m = x + dim.wid / 2;
if (kind_ == NICEFRAC) {
cell(0).draw(pi, x + 2,
y - dim0.des - 5);
cell(1).draw(pi, x + dim0.width() + 5,
y + dim1.asc / 2);
} else if (kind_ == UNITFRAC) {
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
cell(0).draw(pi, x + 2, y - dim0.des - 5);
cell(1).draw(pi, x + dim0.width() + 5, y + dim1.asc / 2);
} else if (kind_ == FRAC || kind_ == ATOP || kind_ == OVER) {
cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc + 2 - 5);
} else if (kind_ == TFRAC) {
// tfrac is in always in text size
StyleChanger dummy2(pi.base, LM_ST_SCRIPT);
cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc + 2 - 5);
} else {
// \cfrac and \dfrac are always in display size
StyleChanger dummy2(pi.base, LM_ST_DISPLAY);
if (kind_ == CFRAC || kind_ == DFRAC)
cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
else if (kind_ == CFRACLEFT)
cell(0).draw(pi, x + 2, y - dim0.des - 2 - 5);
else if (kind_ == CFRACRIGHT)
cell(0).draw(pi, x + dim.wid - dim0.wid - 2,
y - dim0.des - 2 - 5);
cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc + 2 - 5);
}
}
if (kind_ == NICEFRAC || kind_ == UNITFRAC) {
// Diag line:
int xx = x;
if (nargs() == 3)
xx += cell(2).dimension(*pi.base.bv).wid + 5;
pi.pain.line(xx + dim0.wid,
y + dim.des - 2,
xx + dim0.wid + 5,
y - dim.asc + 2, pi.base.font.color());
}
if (kind_ == FRAC || kind_ == CFRAC || kind_ == CFRACLEFT
|| kind_ == CFRACRIGHT || kind_ == DFRAC
|| kind_ == TFRAC || kind_ == OVER)
pi.pain.line(x + 1, y - 5,
x + dim.wid - 2, y - 5, pi.base.font.color());
drawMarkers(pi, x, y);
}
void View::calculateView(boost::shared_ptr<VIEW_AREA> view_area)
{
stringstream subsets_str, axes_str, req_str;
Database db = (*m_Server)[view_area->database];
DIMENSION_LIST dims;
UINT cubeId = (UINT)-1;
if (!view_area->cube.empty()) {
Cube cube = db.cube[view_area->cube];
dims = cube.getCacheData().dimensions;
cubeId = cube.getCacheData().cube;
}
view_area->calc.reset(new VIEW_CALC);
view_area->calc->virt = false;
view_area->calc->dimonaxis.resize(dims.size());
view_area->calc->axes.resize(view_area->axes.size());
{
for (size_t axit = 0; axit < view_area->axes.size(); ++axit) {
if (axit) {
axes_str << "$";
}
if (!view_area->axes[axit].first.empty()) {
boost::shared_ptr<VIEW_AXIS> axe = view_area->axes[axit].second;
if (util::UTF8Comparer::compare(axe->database, view_area->database)) {
string descr = "Databases differ.";
LibPaloNGExceptionFactory::raise(LibPaloNGExceptionFactory::PALO_NG_ERROR_WRONG_PARAMETER, &descr);
}
axes_str << axe->ser_str;
for (size_t subit = 0; subit < axe->as.size(); ++subit) {
boost::shared_ptr<VIEW_SUBSET> sub = axe->as[subit].sub;
if (util::UTF8Comparer::compare(sub->database, view_area->database)) {
string descr = "Databases differ.";
LibPaloNGExceptionFactory::raise(LibPaloNGExceptionFactory::PALO_NG_ERROR_WRONG_PARAMETER, &descr);
}
if (!subsets_str.str().empty()) {
subsets_str << "$";
}
subsets_str << axe->as[subit].subsetHandle << ";" << sub->ser_str;
Dimension d = (*m_Server)[axe->database].dimension[sub->dimension];
size_t i;
for (i = 0; i < dims.size(); ++i) {
if (dims[i] == d.getCacheData().dimension) {
view_area->calc->dimonaxis[i] = make_pair(axit, subit);
view_area->calc->dim2axis[d.getCacheData().ndimension] = i;
break;
}
}
if (!dims.empty() && i == dims.size()) {
stringstream str;
str << "Dimension not in cube. Dimension: " << sub->dimension << " Cube: " << view_area->cube;
string descr = str.str();
LibPaloNGExceptionFactory::raise(LibPaloNGExceptionFactory::PALO_NG_ERROR_WRONG_PARAMETER, &descr);
}
if (d.getCacheData().type == DIMENSION_INFO::SYSTEM_ID) {
view_area->calc->virt = true;
}
}
boost::shared_ptr<VIEW_CALC_AXIS> cl(new VIEW_CALC_AXIS);
view_area->calc->axes[axit] = cl;
cl->nameIndex.resize(axe->as.size());
}
}
}
req_str << "database=" << db.getCacheData().database << "&view_subsets=" << subsets_str.str() << "&view_axes=" << axes_str.str() << "&view_area=" << view_area->ser_str;
if (!view_area->cube.empty()) {
req_str << "&cube=" << cubeId;
}
unsigned int dummy, sequencenumber = 0;
SERVER_TOKEN token(sequencenumber);
unique_ptr<istringstream> stream = m_Server->m_PaloClient->request("/view/calculate", req_str.str(), token, sequencenumber, dummy);
view_area->calc->sequence = m_Server->getDataToken();
boost::shared_ptr<VIEW_CALC_AXIS> curr;
vector<size_t> startLine;
vector<map<IdentifierType, size_t> > knownElems;
bool area = false;
while ((*stream).eof() == false) {
if ((*stream).peek() == '[') {
char line[1024];
(*stream).getline(line, sizeof(line));
string s(line);
if (curr) {
for (size_t i = 0; i < startLine.size(); ++i) {
updateParentChild(curr, startLine[i], i, knownElems);
}
curr.reset();
}
if (s == "[Area]") {
area = true;
} else {
s = s.substr(6, s.size() - 7);
size_t pos = s.find_first_of(' ');
if (pos != string::npos) {
s = s.substr(0, pos);
}
curr = view_area->calc->axes[util::lexicalConversion(size_t, string, s)];
startLine.clear();
startLine.resize(curr->nameIndex.size(), 0);
knownElems.clear();
knownElems.resize(curr->nameIndex.size());
}
} else {
if (area) {
CELL_VALUE_PATH_PROPS val;
CELL_VALUE_PROPS vp;
(*stream) >> csv >> val;
vp = val;
view_area->calc->values[val.path] = vp;
} else {
vector<ELEMENT_INFO_EXT> v;
size_t tuplen = curr->tuples.size();
for (size_t i = 0; i < curr->nameIndex.size(); ++i) {
ELEMENT_INFO_EXT element;
(*stream) >> csv >> element.m_einf;
jedox::util::CsvTokenFromStream tfs((*stream) >> csv);
tfs.get(element.search_alias);
tfs.get(element.path);
if (tuplen) {
if (!hasSameParentSubsets(v, curr->tuples[tuplen - 1], i)) {
updateParentChild(curr, startLine[i], i, knownElems);
knownElems[i].clear();
startLine[i] = tuplen;
}
}
knownElems[i].insert(make_pair(element.m_einf.element, curr->tuples.size()));
v.push_back(element);
curr->nameIndex[i][element.m_einf.nelement] = make_pair(element.m_einf.element, element.m_einf.type);
}
curr->tuples.push_back(v);
}
}
}
/** Given an array of already set up data sets (from e.g. input data files)
* and optional X values, add the sets to this list if they do not exist
* or append any existing sets.
*/
int DataSetList::AddOrAppendSets(std::string const& XlabelIn, Darray const& Xvals,
DataListType const& Sets)
{
if (debug_ > 0)
mprintf("DEBUG: Calling AddOrAppendSets for %zu sets, %zu X values, Xlabel= %s.\n",
Sets.size(), Xvals.size(), XlabelIn.c_str());
if (Sets.empty()) return 0; // No error for now.
// If no X label assume 'Frame' for backwards compat.
std::string Xlabel;
if (XlabelIn.empty())
Xlabel.assign("Frame");
else
Xlabel = XlabelIn;
Dimension Xdim;
// First determine if X values increase monotonically with a regular step
bool isMonotonic = true;
double xstep = 1.0;
if (Xvals.size() > 1) {
xstep = (Xvals.back() - Xvals.front()) / (double)(Xvals.size() - 1);
for (Darray::const_iterator X = Xvals.begin()+2; X != Xvals.end(); ++X)
if ((*X - *(X-1)) - xstep > Constants::SMALL) {
isMonotonic = false;
break;
}
// Set dim even for non-monotonic sets so Label is correct. FIXME is this ok?
Xdim = Dimension( Xvals.front(), xstep, Xlabel );
} else
// No X values. set generic X dim.
Xdim = Dimension(1.0, 1.0, Xlabel);
if (debug_ > 0) {
mprintf("DEBUG: xstep %g xmin %g\n", Xdim.Step(), Xdim.Min());
if (isMonotonic) mprintf("DEBUG: Xdim is monotonic.\n");
}
for (const_iterator ds = Sets.begin(); ds != Sets.end(); ++ds) {
if (*ds == 0) continue; // TODO: Warn about blanks?
if (debug_ > 0) mprintf("DEBUG: AddOrAppend set '%s'", (*ds)->legend());
if (isMonotonic) (*ds)->SetDim(Dimension::X, Xdim);
DataSet* existingSet = CheckForSet( (*ds)->Meta() );
if (existingSet == 0) {
// New set. If set is scalar 1D but X values are not monotonic,
// convert to XY mesh if necessary.
if ( !isMonotonic &&
(*ds)->Group() == DataSet::SCALAR_1D &&
(*ds)->Type() != DataSet::XYMESH )
{
DataSet* xyptr = AddSet( DataSet::XYMESH, (*ds)->Meta() );
if (xyptr == 0) {
mprinterr("Error: Could not convert set %s to XY mesh.\n", (*ds)->legend());
continue; // TODO exit instead?
}
if ( (*ds)->Size() != Xvals.size() ) { // Sanity check
mprinterr("Error: # of X values does not match set %s size.\n", (*ds)->legend());
continue;
}
DataSet_1D const& set = static_cast<DataSet_1D const&>( *(*ds) );
DataSet_Mesh& xy = static_cast<DataSet_Mesh&>( *xyptr );
for (unsigned int i = 0; i != set.Size(); i++)
xy.AddXY( Xvals[i], set.Dval(i) );
xy.SetDim(Dimension::X, Xdim);
if (debug_ > 0) mprintf(", New set, converted to XY-MESH\n");
// Free memory since set has now been converted.
delete *ds;
} else { // No conversion. Just add.
(*ds)->SetDim(Dimension::X, Xdim);
AddSet( *ds );
if (debug_ > 0) mprintf(", New set\n");
}
} else {
if (debug_ > 0) mprintf(", appending to existing set\n");
// Set exists. Try to append this set to existing set.
bool canAppend = true;
if ( (*ds)->Group() == DataSet::GENERIC ) {
// For GENERIC sets, base Type must match. // TODO: Should this logic be in DataSets?
if ( (*ds)->Type() != existingSet->Type() )
canAppend = false;
} else {
// For non-GENERIC sets, Group must match
if ( (*ds)->Group() != existingSet->Group() )
canAppend = false;
}
if (!canAppend)
mprinterr("Error: Cannot append set of type %s to set of type %s\n",
DataArray[(*ds)->Type()].Description,
DataArray[existingSet->Type()].Description);
// If cannot append or attempt to append fails, rename and add as new set.
if (!canAppend || existingSet->Append( *ds )) { // TODO Dimension check?
if (canAppend)
mprintf("Warning: Append currently not supported for type %s\n",
DataArray[existingSet->Type()].Description);
MetaData md = (*ds)->Meta();
md.SetName( GenerateDefaultName("X") );
mprintf("Warning: Renaming %s to %s\n", (*ds)->Meta().PrintName().c_str(),
md.PrintName().c_str());
(*ds)->SetMeta( md );
AddSet( *ds );
} else // Set was appended to existing set; memory can be freed.
delete *ds;
}
} // END loop over input sets
return 0;
}
void UpdateHandlerImpl::extract(UpdateContainer *updateContainer)
{
Rect copyRect;
Point copySrc;
m_screenDriver->getCopiedRegion(©Rect, ©Src);
{
AutoLock al(&m_updateKeeper); // The following operations should be atomic
m_updateKeeper.addCopyRect(©Rect, ©Src);
m_updateKeeper.extract(updateContainer);
}
// Note: The getVideoRegion() function is not a thread safe function, but it invokes
// only from this one place and so that is why it does not cover by the mutex.
m_screenDriver->getVideoRegion(&updateContainer->videoRegion);
// Constrain the video region to the current frame buffer border.
Region fbRect(&m_backupFrameBuffer.getDimension().getRect());
updateContainer->videoRegion.intersect(&fbRect);
updateContainer->videoRegion.intersect(&fbRect);
m_updateFilter->filter(updateContainer);
if (!m_absoluteRect.isEmpty()) {
updateContainer->changedRegion.addRect(&m_screenDriver->getScreenBuffer()->
getDimension().getRect());
m_absoluteRect.clear();
}
// Checking for screen properties changing or frame buffers differ
if (m_screenDriver->getScreenPropertiesChanged() ||
!m_backupFrameBuffer.isEqualTo(m_screenDriver->getScreenBuffer())) {
Dimension currentDimension = m_backupFrameBuffer.getDimension();
Dimension newDimension = m_screenDriver->getScreenDimension();
if (m_screenDriver->getScreenSizeChanged() || !currentDimension.isEqualTo(&newDimension)) {
updateContainer->screenSizeChanged = true;
}
applyNewScreenProperties();
{
// Only this place the class provides frame buffer changings, and then why it
// must be under the mutex. Getters for the backup frame buffer in here (at this function)
// can work without the mutex, but other getters for the frame buffer in other places
// may be invoked from other threads and then it shall cover by the mutex.
AutoLock al(&m_fbLocMut);
m_backupFrameBuffer.clone(m_screenDriver->getScreenBuffer());
}
updateContainer->changedRegion.clear();
updateContainer->copiedRegion.clear();
m_absoluteRect = m_backupFrameBuffer.getDimension().getRect();
m_updateKeeper.setBorderRect(&m_absoluteRect);
}
// Cursor position must always be present.
updateContainer->cursorPos = m_screenDriver->getCursorPosition();
// Checking for mouse shape changing
if (updateContainer->cursorShapeChanged || m_fullUpdateRequested) {
// Update cursor shape
m_screenDriver->grabCursorShape(&m_backupFrameBuffer.getPixelFormat());
// Store cursor shape
m_cursorShape.clone(m_screenDriver->getCursorShape());
m_fullUpdateRequested = false;
}
}
void UnitSystem::addDimension( Dimension dimension ) {
this->m_dimensions[ dimension.getName() ] = std::move( dimension );
}
#include "loadedheatequation.h"
#include <time.h>
void LoadedHeatEquation::Main(int argc UNUSED_PARAM, char** argv UNUSED_PARAM)
{
LoadedHeatEquation ex1;
Dimension time(0.1, 10, 0);
ex1.setTimeDimension(time);
Dimension dim1(0.001, 1000, 0);
ex1.addSpaceDimension(dim1);
ex1.lambda0 = 0.001;
ex1.lambda1 = 1000.0;
ex1.lambda2 = 1.0;
ex1.a = 1.0;
ex1.theta = 3.0;
ex1.L = 3;
ex1.params.resize(ex1.L);
ex1.params[0].k = -1.1; ex1.params[0].z = 10.2; ex1.params[0].e = 0.7415;
ex1.params[1].k = -2.5; ex1.params[1].z = 12.5; ex1.params[1].e = 0.5845;
ex1.params[2].k = -0.1; ex1.params[2].z = 20.5; ex1.params[2].e = 0.7145;
IPrinter::printSeperatorLine("Real process:");
DoubleVector U(dim1.size()+1);
TimeNodePDE tn;
tn.i = 1;//time.sizeN();
tn.t = tn.i*time.step();
for (int n=dim1.min(); n<=dim1.max(); n++)
double Colorization::getScaledValue(PointBuffer& data,
Dimension const& d,
std::size_t pointIndex) const
{
double output(0.0);
float flt(0.0);
boost::int8_t i8(0);
boost::uint8_t u8(0);
boost::int16_t i16(0);
boost::uint16_t u16(0);
boost::int32_t i32(0);
boost::uint32_t u32(0);
boost::int64_t i64(0);
boost::uint64_t u64(0);
boost::uint32_t size = d.getByteSize();
switch (d.getInterpretation())
{
case dimension::Float:
if (size == 4)
{
flt = data.getField<float>(d, pointIndex);
output = static_cast<double>(flt);
}
if (size == 8)
{
output = data.getField<double>(d, pointIndex);
}
break;
case dimension::SignedInteger:
case dimension::SignedByte:
if (size == 1)
{
i8 = data.getField<boost::int8_t>(d, pointIndex);
output = d.applyScaling<boost::int8_t>(i8);
}
if (size == 2)
{
i16 = data.getField<boost::int16_t>(d, pointIndex);
output = d.applyScaling<boost::int16_t>(i16);
}
if (size == 4)
{
i32 = data.getField<boost::int32_t>(d, pointIndex);
output = d.applyScaling<boost::int32_t>(i32);
}
if (size == 8)
{
i64 = data.getField<boost::int64_t>(d, pointIndex);
output = d.applyScaling<boost::int64_t>(i64);
}
break;
case dimension::UnsignedInteger:
case dimension::UnsignedByte:
if (size == 1)
{
u8 = data.getField<boost::uint8_t>(d, pointIndex);
output = d.applyScaling<boost::uint8_t>(u8);
}
if (size == 2)
{
u16 = data.getField<boost::uint16_t>(d, pointIndex);
output = d.applyScaling<boost::uint16_t>(u16);
}
if (size == 4)
{
u32 = data.getField<boost::uint32_t>(d, pointIndex);
output = d.applyScaling<boost::uint32_t>(u32);
}
if (size == 8)
{
u64 = data.getField<boost::uint64_t>(d, pointIndex);
output = d.applyScaling<boost::uint64_t>(u64);
}
break;
case dimension::Pointer: // stored as 64 bits, even on a 32-bit box
case dimension::Undefined:
throw pdal_error("Dimension data type unable to be reprojected");
}
return output;
}
/*************************************************************
* another kind of function that return a set
************************************************************/
std::vector<QueryTuple*> SetFunFactory::funInstance(XSchema* _pSch,
std::string& _cubeName,
SetTypesec _typesec,
std::vector<std::string>& theVector,
FunParam *param)
{
int size = theVector.size();
XCube* pCube = _pSch->getCube(_cubeName);
vector<QueryMember*> QmemVector;
vector<QueryTuple*> QtupleVector;
string dimName = "";
string hieName = "";
Dimension* pDim = NULL;
Hierarchy* pHie = NULL;
if (isDimHie(theVector.at(0)))
{
vector<string> temp = distinct(theVector.at(0));
dimName = temp.at(0);
pDim = pCube->getDimension(temp.at(0));
assert(pDim);
hieName = temp.at(1);
pHie = pDim->getHierarchy(temp.at(1));
assert(pHie);
}
else
{
dimName = theVector.at(0);
pDim = pCube->getDimension(theVector.at(0));
assert(pDim);
pHie = pDim->getDefaultHierarchy();
}
assert(pHie);
hieName = pHie->getName();
//首先把Member从数据库中load出来
pHie->LoadMembers();
switch(_typesec)
{
//函数Members的处理对象
//对于[Time].[Time].[1995].[Q1].[Month].Members
//theVector中应依次存有string：Time, Time, 1995, Q1, Month
case Members:
if (size == 0 )
{
cout<<"error! please input query information..."<<endl;
}
else if (size == 1) //由于现在还不支持多个Hierarchy，所以size 为1、2结果是一样的
{
if ((theVector.at(0) == "Measures")||(theVector.at(0) == "measures"))
{
//元数据现在还没有支持默认度量，先以第一个度量为默认的
vector<Measure*> vecMea = pCube->getMeasures();
vector<Measure*>::iterator meaIterator;
if (!vecMea.empty())
{
for (meaIterator = vecMea.begin(); meaIterator < vecMea.end(); meaIterator++)
{
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setHierarchyName("Measures");
pMem->setLevelName("Measures");
pMem->setVal((*meaIterator)->getName());
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
}
return QtupleVector;
}
else
{
string hierarcyName = pHie->getName();
vector<string> vecLevelName;
// vector< vector<string> > memNameInLevels;//用于存储每个Level上成员名字的vector
vector<Level*> vecLevel = pHie->getLeveles();
Member* temp = (vecLevel.at(0)->getMembers()).at(0);//获取第一个级别第一个成员
getDescendants(temp,dimName,hieName,QtupleVector); // 获取该成员的所有后代
pHie->CleanMembers();
return QtupleVector;
}
}
else if (size == 2)
{
Level* pLevel = pHie->getLevel(theVector.at(1));
vector<Member *> memVector1 = pLevel->getMembers();
if (memVector1.empty())
{
cout<<"empty member vector,do not get the members from database"<<endl;
}
else
{
vector<Member*>::iterator theIterator;
QueryMember *pMem;
for (theIterator = memVector1.begin(); theIterator < memVector1.end(); theIterator++)
{
pMem = DwMemToQryMem(*theIterator,dimName,hieName);
QmemVector.push_back(pMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
}
else if(size >= 3) // [Time.Time].[Month].[Day].Members
{
cout<<"Members funtion error,too much member"<<endl;
return 0;
}
break;
//函数AllMembers,参考SQL Server联机丛书
//返回包含指定维度或级别的所有成员的集合，包括计算成员。
//注：暂时不考虑计算成员的处理,此时功能和Members功能差不多
case AllMembers:
if (size == 0 )
{
cout<<"error! please input the query information!"<<endl;
}
else
{
if (size == 1)
{
std::auto_ptr<QueryMember>pMem(new QueryMember);
pMem->setVal("All");
pMem->setDimensionName(dimName); // add by eason
pMem->setHierarchyName(hieName);
pMem->setLevelName("All");
QmemVector.push_back(pMem.release());
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
return QtupleVector;
}
else if(size == 2)//[Time].[Quarter].AllMembers
{
pHie->LoadMembers(); //首先把Member从数据库中load出来 add by eason
Level* pLevel = pHie->getLevel(theVector.at(size-1));
vector<Member*> memVector = pLevel->getMembers();
vector<Member*>::iterator theIterator;
QueryMember *pMem;
for (theIterator = memVector.begin(); theIterator < memVector.end(); theIterator++)
{
pMem = DwMemToQryMem(*theIterator,dimName,hieName);
QmemVector.push_back(pMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else //[Time].[Year].[Month].AllMembers
{
cout<<"AllMembers funtion error,too much member"<<endl;
return 0;
}
}
break;
case Children:
{
//注：JPivot里面是不可能出现这种情况的
//因为一旦出现，JPivot会自动转化成加一个CurrentMember函数
//如：[Time].Children会自动转变成[Time].CurrentMember.Children
bool isall = false;
if (size == 1)
{
cout<<"error! invalid using of Children"<<endl;
}
else
{
vector<Level*> levelVec = pHie->getLeveles();
Member* mem = levelVec.at(0)->getMember(theVector.at(1), 0);
for (int i = 1; i < size-1; i++)
{
mem = levelVec.at(i)->getMember(theVector.at(i+1), mem);
}
vector<Member*> memVec = mem->getChildrenMember();
vector<Member*>::iterator memIterator;
QueryMember * ptr;
for (memIterator = memVec.begin(); memIterator < memVec.end(); memIterator++)
{
ptr = DwMemToQryMem(*memIterator,dimName,hieName);
QmemVector.push_back(ptr);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
break;
}
//下一个函数起点
case Siblings:
if(size >= 2){
vector<Level*> levelVec = pHie->getLeveles();
Level *pLevel = levelVec.at(0);
Member* temp = levelVec.at(0)->getMember(theVector.at(1), 0);
for (int i = 1; i < size-1; i++)
{
temp = levelVec.at(i)->getMember(theVector.at(i+1), temp);
pLevel = levelVec.at(i); //兄弟成员所在的level
}
Member* pMem = temp->getParent();
vector<Member *> memVec;
if(!pMem) //不存在父成员,如Time.1998
{
memVec = pLevel->getMembers();
}
else
{
memVec = pMem->getChildrenMember();
}
vector<Member *>::iterator memIterator;
QueryMember *ptr;
for(memIterator = memVec.begin();memIterator != memVec.end();memIterator++)
{
ptr = DwMemToQryMem(*memIterator,dimName,hieName);
QmemVector.push_back(ptr);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
pHie->CleanMembers();
return QtupleVector;
}
else
{
cout<<"Siblings funtion error,too less member"<<endl;
return 0;
}
break;
case Descendants:
{
Level *ancLevel; //先代成员所在的level
Level *decLevel; //后代成员所在的level
vector<Level*> levelVec = pHie->getLeveles();
Member* ancMember = levelVec.at(0)->getMember(theVector.at(1), 0);
//定位目标成员
for (int i = 1; i < size-1; i++)
{
ancMember = levelVec.at(i)->getMember(theVector.at(i+1), ancMember);
ancLevel = levelVec.at(i);
}
if(param->getHasIntParam() || param->getHasStrParam())
{
if(param->getHasIntParam()) //如果包含数字型参数
{
int num = param->getIntParam();
decLevel = ancLevel;
if(num>0)
{
// 定位目标级别
for(int j=0;j<num;j++)
{
decLevel = decLevel ->getChildLevel();
assert(decLevel); //不存在该级别
}
}
}
if(param->getHasStrParam()) //如果包含字符型参数
{
char *str = param->getStrParam();
// 定位目标级别
decLevel = pHie->getLevel(str);
assert(decLevel); //不存在该级别
}
vector<Member *> _mem = decLevel->getMembers();
vector<QueryMember*> QmemVector;
QueryMember* ancMem = DwMemToQryMem(ancMember,dimName,hieName);
QueryMember* decMem;
for(int i = 0; i< _mem.size(); i++)
{
decMem = DwMemToQryMem(_mem.at(i),dimName,hieName);
//此处仍可改进，没必要遍历级别上的所有成员
if(isAncestor(ancMem, decMem))
{
QmemVector.push_back(decMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
}
}
}
else //如果不含参数
{
getDescendants(ancMember,dimName,hieName,QtupleVector);
}
pHie->CleanMembers();
return QtupleVector;
}
break;
case Ascendants:
{
vector<Level*> levelVec = pHie->getLeveles();
Member* decMember = levelVec.at(0)->getMember(theVector.at(1), 0);
//定位目标成员
for (int i = 1; i < size-1; i++)
{
decMember = levelVec.at(i)->getMember(theVector.at(i+1), decMember);
assert(decMember);
}
vector<QueryMember*> QmemVector;
QueryMember * ancQryMem;
Member* ancMember = decMember ;
while(ancMember)
{
ancQryMem = DwMemToQryMem(ancMember,dimName,hieName);
QmemVector.push_back(ancQryMem);
std::auto_ptr<QueryTuple>pTuple(new QueryTuple(QmemVector));
QmemVector.pop_back();
QtupleVector.push_back(pTuple.release());
ancMember = ancMember->getParent();
}
pHie->CleanMembers();
return QtupleVector;
}
break;
}
}
