-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
throw INTERP_KERNEL::Exception("DataArrayChar::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
}
-std::size_t DataArrayChar::getHeapMemorySize() const
+/*!
+ * This method desallocated \a this without modification of informations relative to the components.
+ * After call of this method, DataArrayChar::isAllocated will return false.
+ * If \a this is already not allocated, \a this is let unchanged.
+ */
+void DataArrayChar::desallocate() throw(INTERP_KERNEL::Exception)
{
- std::size_t sz=(std::size_t)_mem.getNbOfElemAllocated();
- return DataArray::getHeapMemorySize()+sz;
+ _mem.destroy();
}
-/*!
- * Sets information on all components. This method can change number of components
- * at certain conditions; if the conditions are not respected, an exception is thrown.
- * The number of components can be changed provided that \a this is not allocated.
- *
- * To know more on format of the component information see
- * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
- * \param [in] info - a vector of component infos.
- * \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
- */
-void DataArrayChar::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
+std::size_t DataArrayChar::getHeapMemorySize() const
{
- if(getNumberOfComponents()!=(int)info.size())
- {
- if(!isAllocated())
- _info_on_compo=info;
- else
- {
- std::ostringstream oss; oss << "DataArrayChar::setInfoAndChangeNbOfCompo : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " and this is already allocated !";
- throw INTERP_KERNEL::Exception(oss.str().c_str());
- }
- }
- else
- _info_on_compo=info;
+ std::size_t sz=_mem.getNbOfElemAllocated();
+ return DataArray::getHeapMemorySize()+sz;
}
/*!
int DataArrayChar::getHashCode() const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- int nbOfElems=getNbOfElems();
+ std::size_t nbOfElems=getNbOfElems();
int ret=nbOfElems*65536;
int delta=3;
if(nbOfElems>48)
delta=nbOfElems/8;
int ret0=0;
const char *pt=begin();
- for(int i=0;i<nbOfElems;i+=delta)
+ for(std::size_t i=0;i<nbOfElems;i+=delta)
ret0+=pt[i];
return ret+ret0;
}
int nbOfTuples=other.getNumberOfTuples();
int nbOfComp=other.getNumberOfComponents();
allocIfNecessary(nbOfTuples,nbOfComp);
- int nbOfElems=nbOfTuples*nbOfComp;
+ std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
char *pt=getPointer();
const char *ptI=other.getConstPointer();
- for(int i=0;i<nbOfElems;i++)
+ for(std::size_t i=0;i<nbOfElems;i++)
pt[i]=ptI[i];
copyStringInfoFrom(other);
}
*
* \sa DataArrayChar::pack, DataArrayChar::pushBackSilent, DataArrayChar::pushBackValsSilent
*/
-void DataArrayChar::reserve(int nbOfElems) throw(INTERP_KERNEL::Exception)
+void DataArrayChar::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
{
int nbCompo=getNumberOfComponents();
if(nbCompo==1)
if(nbOfTuple<0 || nbOfCompo<0)
throw INTERP_KERNEL::Exception("DataArrayChar::alloc : request for negative length of data !");
_info_on_compo.resize(nbOfCompo);
- _mem.alloc(nbOfCompo*nbOfTuple);
+ _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
declareAsNew();
}
return _mem.isEqual(other._mem,0,tmp);
}
+/*!
+ * Reverse the array values.
+ * \throw If \a this->getNumberOfComponents() < 1.
+ * \throw If \a this is not allocated.
+ */
+void DataArrayChar::reverse() throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ _mem.reverse(getNumberOfComponents());
+ declareAsNew();
+}
+
/*!
* Assign zero to all values in \a this array. To know more on filling arrays see
* \ref MEDCouplingArrayFill.
* than the current number the array is truncated, otherwise the array is extended.
* \param [in] nbOfTuples - new number of tuples.
* \throw If \a this is not allocated.
+ * \throw If \a nbOfTuples is negative.
*/
void DataArrayChar::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
{
+ if(nbOfTuples<0)
+ throw INTERP_KERNEL::Exception("DataArrayChar::reAlloc : input new number of tuples should be >=0 !");
checkAllocated();
- _mem.reAlloc(getNumberOfComponents()*nbOfTuples);
+ _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
declareAsNew();
}
checkAllocated();
DataArrayInt *ret=DataArrayInt::New();
ret->alloc(getNumberOfTuples(),getNumberOfComponents());
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
const char *src=getConstPointer();
int *dest=ret->getPointer();
std::copy(src,src+nbOfVals,dest);
return ret.retn();
}
+/*!
+ * Returns a shorten and permuted copy of \a this array. The new DataArrayChar is
+ * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
+ * \a new2OldBg array.
+ * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
+ * This method is equivalent to renumberAndReduce() except that convention in input is
+ * \c new2old and \b not \c old2new.
+ * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
+ * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
+ * tuple index in \a this array to fill the i-th tuple in the new array.
+ * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
+ * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
+ * \a new2OldBg <= \a pi < \a new2OldEnd.
+ * \return DataArrayChar * - the new instance of DataArrayChar that the caller
+ * is to delete using decrRef() as it is no more needed.
+ */
+DataArrayChar *DataArrayChar::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
+{
+ return selectByTupleIdSafe(new2OldBg,new2OldEnd);
+}
+
/*!
* Returns a shorten and permuted copy of \a this array. The new DataArrayChar is
* of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayChar> ret=buildEmptySpecializedDAChar();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=GetNumberOfItemGivenBES(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
+ int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
ret->alloc(newNbOfTuples,nbComp);
char *pt=ret->getPointer();
const char *srcPt=getConstPointer()+bg*nbComp;
* \param [in] newNbOfComp - number of components for \a this array to have.
* \throw If \a this is not allocated
* \throw If getNbOfElems() % \a newNbOfCompo != 0.
+ * \throw If \a newNbOfCompo is lower than 1.
+ * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
* \warning This method erases all (name and unit) component info set before!
*/
void DataArrayChar::rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- int nbOfElems=getNbOfElems();
+ if(newNbOfCompo<1)
+ throw INTERP_KERNEL::Exception("DataArrayChar::rearrange : input newNbOfCompo must be > 0 !");
+ std::size_t nbOfElems=getNbOfElems();
if(nbOfElems%newNbOfCompo!=0)
throw INTERP_KERNEL::Exception("DataArrayChar::rearrange : nbOfElems%newNbOfCompo!=0 !");
+ if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
+ throw INTERP_KERNEL::Exception("DataArrayChar::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
_info_on_compo.clear();
_info_on_compo.resize(newNbOfCompo);
declareAsNew();
}
+/*!
+ * Returns a shorten copy of \a this array. The new DataArrayChar contains all
+ * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
+ * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
+ * This method is a specialization of selectByTupleId2().
+ * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
+ * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
+ * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
+ * \return DataArrayChar * - the new instance of DataArrayChar that the caller
+ * is to delete using decrRef() as it is no more needed.
+ * \throw If \a tupleIdBg < 0.
+ * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
+ \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
+ * \sa DataArrayChar::selectByTupleId2
+ */
+DataArrayChar *DataArrayChar::substr(int tupleIdBg, int tupleIdEnd) const throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ int nbt=getNumberOfTuples();
+ if(tupleIdBg<0)
+ throw INTERP_KERNEL::Exception("DataArrayChar::substr : The tupleIdBg parameter must be greater than 0 !");
+ if(tupleIdBg>nbt)
+ throw INTERP_KERNEL::Exception("DataArrayChar::substr : The tupleIdBg parameter is greater than number of tuples !");
+ int trueEnd=tupleIdEnd;
+ if(tupleIdEnd!=-1)
+ {
+ if(tupleIdEnd>nbt)
+ throw INTERP_KERNEL::Exception("DataArrayChar::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
+ }
+ else
+ trueEnd=nbt;
+ int nbComp=getNumberOfComponents();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayChar> ret=buildEmptySpecializedDAChar();
+ ret->alloc(trueEnd-tupleIdBg,nbComp);
+ ret->copyStringInfoFrom(*this);
+ std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
+ return ret.retn();
+}
+
/*!
* Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
* than \a this->getNumberOfComponents() then the result array is shorten as each tuple
* components.
* \param [in] newNbOfComp - number of components for the new array to have.
* \param [in] dftValue - value assigned to new values added to the new array.
- * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
+ * \return DataArrayChar * - the new instance of DataArrayChar that the caller
* is to delete using decrRef() as it is no more needed.
* \throw If \a this is not allocated.
*/
* \throw If a component index (\a i) is not valid:
* \a i < 0 || \a i >= \a this->getNumberOfComponents().
*
- * \ref cpp_mcdataarrayint_keepselectedcomponents "Here is a Python example".
+ * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
*/
-DataArrayChar *DataArrayChar::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
+DataArray *DataArrayChar::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayChar> ret(buildEmptySpecializedDAChar());
throw INTERP_KERNEL::Exception("DataArrayChar::meldWith : mismatch of number of tuples !");
int nbOfComp1=getNumberOfComponents();
int nbOfComp2=other->getNumberOfComponents();
- char *newArr=new char[nbOfTuples*(nbOfComp1+nbOfComp2)];
+ char *newArr=(char *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(char));
char *w=newArr;
const char *inp1=getConstPointer();
const char *inp2=other->getConstPointer();
w=std::copy(inp1,inp1+nbOfComp1,w);
w=std::copy(inp2,inp2+nbOfComp2,w);
}
- useArray(newArr,true,CPP_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
+ useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
std::vector<int> compIds(nbOfComp2);
for(int i=0;i<nbOfComp2;i++)
compIds[i]=nbOfComp1+i;
* \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
* \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
*
- * \ref cpp_mcdataarrayint_setpartofvalues1 "Here is a Python example".
+ * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
*/
void DataArrayChar::setPartOfValues1(const DataArrayChar *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
{
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
- * \ref cpp_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
+ * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
*/
void DataArrayChar::setPartOfValuesSimple1(char a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
{
* \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
* <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
*
- * \ref cpp_mcdataarrayint_setpartofvalues2 "Here is a Python example".
+ * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
*/
void DataArrayChar::setPartOfValues2(const DataArrayChar *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
{
int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
int newNbOfComp=(int)std::distance(bgComp,endComp);
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
for(const int *z=bgComp;z!=endComp;z++,srcPt++)
{
- pt[(*w)*nbComp+(*z)]=*srcPt;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
}
}
}
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
{
- pt[(*w)*nbComp+(*z)]=*srcPt2;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
}
}
}
* \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
* out of a valid range for \a this array.
*
- * \ref cpp_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
+ * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
*/
void DataArrayChar::setPartOfValuesSimple2(char a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
{
for(const int *z=bgComp;z!=endComp;z++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+(*z)]=a;
+ pt[(std::size_t)(*w)*nbComp+(*z)]=a;
}
}
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
- * \ref cpp_mcdataarrayint_setpartofvalues3 "Here is a Python example".
+ * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
*/
void DataArrayChar::setPartOfValues3(const DataArrayChar *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
{
DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
for(int j=0;j<newNbOfComp;j++,srcPt++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=*srcPt;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
}
}
else
for(int j=0;j<newNbOfComp;j++,srcPt2++)
{
DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
- pt[(*w)*nbComp+j*stepComp]=*srcPt2;
+ pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
}
}
}
* non-empty range of increasing indices or indices are out of a valid range
* for \this array.
*
- * \ref cpp_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
+ * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
*/
void DataArrayChar::setPartOfValuesSimple3(char a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
{
int nbOfTuples=getNumberOfTuples();
DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
bool assignTech=true;
- if(a->getNbOfElems()==newNbOfTuples*newNbOfComp)
+ if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
{
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
}
}
+/*!
+ * Copy some tuples from another DataArrayChar (\a aBase) into contiguous tuples
+ * of \a this array. Textual data is not copied. Both arrays must have equal number of
+ * components.
+ * The tuples to assign to are defined by index of the first tuple, and
+ * their number is defined by \a tuplesSelec->getNumberOfTuples().
+ * The tuples to copy are defined by values of a DataArrayChar.
+ * All components of selected tuples are copied.
+ * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
+ * values to.
+ * \param [in] aBase - the array to copy values from.
+ * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
+ * \throw If \a this is not allocated.
+ * \throw If \a aBase is NULL.
+ * \throw If \a aBase is not allocated.
+ * \throw If \a tuplesSelec is NULL.
+ * \throw If \a tuplesSelec is not allocated.
+ * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
+ * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
+ * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
+ * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
+ * \a aBase array.
+ */
+void DataArrayChar::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
+{
+ if(!aBase || !tuplesSelec)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues : input DataArray is NULL !");
+ const DataArrayChar *a=dynamic_cast<const DataArrayChar *>(aBase);
+ if(!a)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayChar !");
+ checkAllocated();
+ a->checkAllocated();
+ tuplesSelec->checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ if(nbOfComp!=a->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues : This and a do not have the same number of components !");
+ if(tuplesSelec->getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayChar instance with exactly 1 component !");
+ int thisNt=getNumberOfTuples();
+ int aNt=a->getNumberOfTuples();
+ int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
+ char *valsToSet=getPointer()+tupleIdStart*nbOfComp;
+ if(tupleIdStart+nbOfTupleToWrite>thisNt)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues : invalid number range of values to write !");
+ const char *valsSrc=a->getConstPointer();
+ for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
+ {
+ if(*tuple>=0 && *tuple<aNt)
+ {
+ std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayChar::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
+ oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+}
+
+/*!
+ * Copy some tuples from another DataArrayChar (\a aBase) into contiguous tuples
+ * of \a this array. Textual data is not copied. Both arrays must have equal number of
+ * components.
+ * The tuples to copy are defined by three values similar to parameters of
+ * the Python function \c range(\c start,\c stop,\c step).
+ * The tuples to assign to are defined by index of the first tuple, and
+ * their number is defined by number of tuples to copy.
+ * All components of selected tuples are copied.
+ * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
+ * values to.
+ * \param [in] aBase - the array to copy values from.
+ * \param [in] bg - index of the first tuple to copy of the array \a aBase.
+ * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
+ * are located.
+ * \param [in] step - index increment to get index of the next tuple to copy.
+ * \throw If \a this is not allocated.
+ * \throw If \a aBase is NULL.
+ * \throw If \a aBase is not allocated.
+ * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
+ * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
+ * \throw If parameters specifying tuples to copy, do not give a
+ * non-empty range of increasing indices or indices are out of a valid range
+ * for the array \a aBase.
+ */
+void DataArrayChar::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
+{
+ if(!aBase)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues2 : input DataArray is NULL !");
+ const DataArrayChar *a=dynamic_cast<const DataArrayChar *>(aBase);
+ if(!a)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayChar !");
+ checkAllocated();
+ a->checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ const char msg[]="DataArrayChar::setContigPartOfSelectedValues2";
+ int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
+ if(nbOfComp!=a->getNumberOfComponents())
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
+ int thisNt=getNumberOfTuples();
+ int aNt=a->getNumberOfTuples();
+ char *valsToSet=getPointer()+tupleIdStart*nbOfComp;
+ if(tupleIdStart+nbOfTupleToWrite>thisNt)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues2 : invalid number range of values to write !");
+ if(end2>aNt)
+ throw INTERP_KERNEL::Exception("DataArrayChar::setContigPartOfSelectedValues2 : invalid range of values to read !");
+ const char *valsSrc=a->getConstPointer()+bg*nbOfComp;
+ for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
+ {
+ std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
+ }
+}
+
+/*!
+ * Returns a shorten copy of \a this array. The new DataArrayChar contains ranges
+ * of tuples specified by \a ranges parameter.
+ * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
+ * \param [in] ranges - std::vector of std::pair's each of which defines a range
+ * of tuples in [\c begin,\c end) format.
+ * \return DataArrayChar * - the new instance of DataArrayChar that the caller
+ * is to delete using decrRef() as it is no more needed.
+ * \throw If \a end < \a begin.
+ * \throw If \a end > \a this->getNumberOfTuples().
+ * \throw If \a this is not allocated.
+ */
+DataArray *DataArrayChar::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ int nbOfComp=getNumberOfComponents();
+ int nbOfTuplesThis=getNumberOfTuples();
+ if(ranges.empty())
+ {
+ MEDCouplingAutoRefCountObjectPtr<DataArrayChar> ret=buildEmptySpecializedDAChar();
+ ret->alloc(0,nbOfComp);
+ ret->copyStringInfoFrom(*this);
+ return ret.retn();
+ }
+ int ref=ranges.front().first;
+ int nbOfTuples=0;
+ bool isIncreasing=true;
+ for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
+ {
+ if((*it).first<=(*it).second)
+ {
+ if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
+ {
+ nbOfTuples+=(*it).second-(*it).first;
+ if(isIncreasing)
+ isIncreasing=ref<=(*it).first;
+ ref=(*it).second;
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayChar::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
+ oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ else
+ {
+ std::ostringstream oss; oss << "DataArrayChar::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
+ oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
+ throw INTERP_KERNEL::Exception(oss.str().c_str());
+ }
+ }
+ if(isIncreasing && nbOfTuplesThis==nbOfTuples)
+ return deepCpy();
+ MEDCouplingAutoRefCountObjectPtr<DataArrayChar> ret=buildEmptySpecializedDAChar();
+ ret->alloc(nbOfTuples,nbOfComp);
+ ret->copyStringInfoFrom(*this);
+ const char *src=getConstPointer();
+ char *work=ret->getPointer();
+ for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
+ work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
+ return ret.retn();
+}
+
/*!
* Returns a value located at specified tuple and component.
* This method is equivalent to DataArrayChar::getIJ() except that validity of
* all values of \a this.
* \param [in] tupleId - index of tuple of interest.
* \param [in] compoId - index of component of interest.
- * \return double - value located by \a tupleId and \a compoId.
+ * \return char - value located by \a tupleId and \a compoId.
* \throw If \a this is not allocated.
* \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
* \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
std::ostringstream oss; oss << "DataArrayChar::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- return _mem[tupleId*((int)_info_on_compo.size())+compoId];
+ return _mem[tupleId*_info_on_compo.size()+compoId];
+}
+
+/*!
+ * Returns the first value of \a this.
+ * \return char - the last value of \a this array.
+ * \throw If \a this is not allocated.
+ * \throw If \a this->getNumberOfComponents() != 1.
+ * \throw If \a this->getNumberOfTuples() < 1.
+ */
+char DataArrayChar::front() const throw(INTERP_KERNEL::Exception)
+{
+ checkAllocated();
+ if(getNumberOfComponents()!=1)
+ throw INTERP_KERNEL::Exception("DataArrayChar::front : number of components not equal to one !");
+ int nbOfTuples=getNumberOfTuples();
+ if(nbOfTuples<1)
+ throw INTERP_KERNEL::Exception("DataArrayChar::front : number of tuples must be >= 1 !");
+ return *(getConstPointer());
}
/*!
* Returns the last value of \a this.
- * \return double - the last value of \a this array.
+ * \return char - the last value of \a this array.
* \throw If \a this is not allocated.
* \throw If \a this->getNumberOfComponents() != 1.
* \throw If \a this->getNumberOfTuples() < 1.
if(nbOfCompo!=1)
throw INTERP_KERNEL::Exception("DataArrayChar::search : works only for DataArrayChar instance with one component !");
const char *cptr=getConstPointer();
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
const char *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
if(loc!=cptr+nbOfVals)
return std::distance(cptr,loc);
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
const char *cptr=getConstPointer();
- int nbOfVals=getNbOfElems();
+ std::size_t nbOfVals=getNbOfElems();
for(const char *work=cptr;work!=cptr+nbOfVals;)
{
work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
/*!
* Returns the maximal value and its location within \a this one-dimensional array.
* \param [out] tupleId - index of the tuple holding the maximal value.
- * \return double - the maximal value among all values of \a this array.
+ * \return char - the maximal value among all values of \a this array.
* \throw If \a this->getNumberOfComponents() != 1
* \throw If \a this->getNumberOfTuples() < 1
*/
* this[*id] in [\b vmin,\b vmax)
*
* \param [in] vmin begin of range. This value is included in range.
- * \param [out] vmax end of range. This value is \b not included in range.
+ * \param [in] vmax end of range. This value is \b not included in range.
* \return a newly allocated data array that the caller should deal with.
*/
DataArrayInt *DataArrayChar::getIdsInRange(char vmin, char vmax) const throw(INTERP_KERNEL::Exception)
void DataArrayChar::useArray(const char *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
_info_on_compo.resize(nbOfCompo);
- _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
+ _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
declareAsNew();
}
void DataArrayChar::useExternalArrayWithRWAccess(const char *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
{
_info_on_compo.resize(nbOfCompo);
- _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
+ _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
declareAsNew();
}
* \ref MEDCouplingArrayBasicsCopyDeep.
* \return DataArrayByte * - a new instance of DataArrayByte.
*/
-DataArrayByte *DataArrayByte::deepCpy() const
+DataArrayByte *DataArrayByte::deepCpy() const throw(INTERP_KERNEL::Exception)
{
return new DataArrayByte(*this);
}
/*!
* Returns the only one value in \a this, if and only if number of elements
* (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
- * \return double - the sole value stored in \a this array.
+ * \return char - the sole value stored in \a this array.
* \throw If at least one of conditions stated above is not fulfilled.
*/
char DataArrayByte::byteValue() const throw(INTERP_KERNEL::Exception)
void DataArrayByte::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
{
DataArray::reprWithoutNameStream(stream);
- _mem.repr(getNumberOfComponents(),stream);
+ if(_mem.reprHeader(getNumberOfComponents(),stream))
+ {
+ const char *data=begin();
+ int nbOfTuples=getNumberOfTuples();
+ int nbCompo=getNumberOfComponents();
+ for(int i=0;i<nbOfTuples;i++,data+=nbCompo)
+ {
+ stream << "Tuple #" << i << " : ";
+ std::copy(data,data+nbCompo,std::ostream_iterator<int>(stream," "));//it is not a bug int here not char because it is not ASCII here contrary to DataArrayAsciiChar
+ stream << "\n";
+ }
+ }
}
void DataArrayByte::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
}
+/*!
+ * Method that gives a quick overvien of \a this for python.
+ */
+void DataArrayByte::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+{
+ static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
+ stream << "DataArrayByte C++ instance at " << this << ". ";
+ if(isAllocated())
+ {
+ int nbOfCompo=(int)_info_on_compo.size();
+ if(nbOfCompo>=1)
+ {
+ int nbOfTuples=getNumberOfTuples();
+ stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
+ reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
+ }
+ else
+ stream << "Number of components : 0.";
+ }
+ else
+ stream << "*** No data allocated ****";
+}
+
+void DataArrayByte::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
+{
+ const char *data=begin();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfCompo=(int)_info_on_compo.size();
+ std::ostringstream oss2; oss2 << "[";
+ std::string oss2Str(oss2.str());
+ bool isFinished=true;
+ for(int i=0;i<nbOfTuples && isFinished;i++)
+ {
+ if(nbOfCompo>1)
+ {
+ oss2 << "(";
+ for(int j=0;j<nbOfCompo;j++,data++)
+ {
+ oss2 << (int)*data;
+ if(j!=nbOfCompo-1) oss2 << ", ";
+ }
+ oss2 << ")";
+ }
+ else
+ { oss2 << (int)*data; data++; }
+ if(i!=nbOfTuples-1) oss2 << ", ";
+ std::string oss3Str(oss2.str());
+ if(oss3Str.length()<maxNbOfByteInRepr)
+ oss2Str=oss3Str;
+ else
+ isFinished=false;
+ }
+ stream << oss2Str;
+ if(!isFinished)
+ stream << "... ";
+ stream << "]";
+}
+
bool DataArrayByte::isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
{
const DataArrayByte *otherC=dynamic_cast<const DataArrayByte *>(&other);
* \ref MEDCouplingArrayBasicsCopyDeep.
* \return DataArrayAsciiChar * - a new instance of DataArrayAsciiChar.
*/
-DataArrayAsciiChar *DataArrayAsciiChar::deepCpy() const
+DataArrayAsciiChar *DataArrayAsciiChar::deepCpy() const throw(INTERP_KERNEL::Exception)
{
return new DataArrayAsciiChar(*this);
}
/*!
* Returns the only one value in \a this, if and only if number of elements
* (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
- * \return double - the sole value stored in \a this array.
+ * \return char - the sole value stored in \a this array.
* \throw If at least one of conditions stated above is not fulfilled.
*/
char DataArrayAsciiChar::asciiCharValue() const throw(INTERP_KERNEL::Exception)
stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
}
+/*!
+ * Method that gives a quick overvien of \a this for python.
+ */
+void DataArrayAsciiChar::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
+{
+ static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
+ stream << "DataArrayAsciiChar C++ instance at " << this << ". ";
+ if(isAllocated())
+ {
+ int nbOfCompo=(int)_info_on_compo.size();
+ if(nbOfCompo>=1)
+ {
+ int nbOfTuples=getNumberOfTuples();
+ stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
+ reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
+ }
+ else
+ stream << "Number of components : 0.";
+ }
+ else
+ stream << "*** No data allocated ****";
+}
+
+void DataArrayAsciiChar::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
+{
+ const char *data=begin();
+ int nbOfTuples=getNumberOfTuples();
+ int nbOfCompo=(int)_info_on_compo.size();
+ std::ostringstream oss2; oss2 << "[";
+ std::string oss2Str(oss2.str());
+ bool isFinished=true;
+ for(int i=0;i<nbOfTuples && isFinished;i++)
+ {
+ bool isAscii=true;
+ for(int j=0;j<nbOfCompo;j++)
+ if(data[j]<32) isAscii=false;
+ if(isAscii)
+ {
+ oss2 << "\'";
+ for(int j=0;j<nbOfCompo;j++,data++)
+ oss2 << *data;
+ oss2 << "\'";
+ }
+ else
+ {
+ oss2 << "(";
+ for(int j=0;j<nbOfCompo;j++,data++)
+ {
+ oss2 << (int)*data;
+ if(j!=nbOfCompo-1) oss2 << ", ";
+ }
+ oss2 << ")";
+ }
+ if(i!=nbOfTuples-1) oss2 << ", ";
+ std::string oss3Str(oss2.str());
+ if(oss3Str.length()<maxNbOfByteInRepr)
+ oss2Str=oss3Str;
+ else
+ isFinished=false;
+ }
+ stream << oss2Str;
+ if(!isFinished)
+ stream << "... ";
+ stream << "]";
+}
+
bool DataArrayAsciiChar::isEqualIfNotWhy(const DataArrayChar& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
{
const DataArrayAsciiChar *otherC=dynamic_cast<const DataArrayAsciiChar *>(&other);
