bool check(char x, char y){
if (jan(x) and jan(y)){
if (((x-'a') == (y-'a')) or ((x-'A') == (y-'A')) or ((x-'a') == (y-'A')) or ((x-'A') == (y-'a'))){
return true;
}
}
return false;
}
void ListDatatypeValidator::inspectFacetBase(MemoryManager* const manager)
{
//
// we are pretty sure baseValidator is not null
//
if (getBaseValidator()->getType() == DatatypeValidator::List)
{
AbstractStringValidator::inspectFacetBase(manager);
}
else
{
// the first level ListDTV
// check 4.3.5.c0 must: enumeration values from the value space of base
if ( ((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) != 0) &&
(getEnumeration() !=0) )
{
int i;
int enumLength = getEnumeration()->size();
try
{
for ( i = 0; i < enumLength; i++)
{
// ask the itemType for a complete check
BaseRefVectorOf<XMLCh>* tempList = XMLString::tokenizeString(getEnumeration()->elementAt(i), manager);
Janitor<BaseRefVectorOf<XMLCh> > jan(tempList);
int tokenNumber = tempList->size();
try
{
for ( int j = 0; j < tokenNumber; j++)
getBaseValidator()->validate(tempList->elementAt(j), (ValidationContext*)0, manager);
}
catch(const OutOfMemoryException&)
{
jan.release();
throw;
}
// enum shall pass this->checkContent() as well.
checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
}
}
catch ( XMLException& )
{
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
, XMLExcepts::FACET_enum_base
, getEnumeration()->elementAt(i)
, manager);
}
}
}
}// End of inspectFacetBase()
void NOTATIONDatatypeValidator::checkContent( const XMLCh* const content
, ValidationContext* const context
, bool asBase
, MemoryManager* const manager
)
{
//validate against base validator if any
NOTATIONDatatypeValidator *pBaseValidator = (NOTATIONDatatypeValidator*) this->getBaseValidator();
if (pBaseValidator)
pBaseValidator->checkContent(content, context, true, manager);
int thisFacetsDefined = getFacetsDefined();
// we check pattern first
if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
{
if (getRegex()->matches(content, manager) ==false)
{
ThrowXMLwithMemMgr2(InvalidDatatypeValueException
, XMLExcepts::VALUE_NotMatch_Pattern
, content
, getPattern()
, manager);
}
}
// if this is a base validator, we only need to check pattern facet
// all other facet were inherited by the derived type
if (asBase)
return;
checkValueSpace(content, manager);
if ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0 &&
(getEnumeration() != 0))
{
XMLCh* normContent = XMLString::replicate(content, manager);
ArrayJanitor<XMLCh> jan(normContent, manager);
normalizeContent(normContent, manager);
int i=0;
int enumLength = getEnumeration()->size();
for ( ; i < enumLength; i++)
{
if (XMLString::equals(normContent, getEnumeration()->elementAt(i)))
break;
}
if (i == enumLength)
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
}
checkAdditionalFacet(content, manager);
}
bool isPalindrome(string s) {
int n = s.length();
int i = 0, j = n-1;
while(i<=j){
if (!jan(s[i])) {
++i; continue;
}
if (!jan(s[j])) {
--j; continue;
}
if (check(s[i],s[j])){
++i;--j;
continue;
}
else{
return false;
}
}
return true;
}
void XMLStringUtil::Space2Hex(XMLCh* const str)
{
XMLCh hexVal[4] = {chPercent,chDigit_2,chDigit_0,chNull};
XMLCh tempBuf[512];
XMLString::copyString(tempBuf,str);
BaseRefVectorOf<XMLCh>* parts = XMLString::tokenizeString(tempBuf);
Janitor<BaseRefVectorOf<XMLCh> > jan(parts);
if (parts->size()) {
XMLString::copyString(str,parts->elementAt(0));
for(size_t i=1,is=parts->size();i<is;++i) {
XMLString::catString(str,hexVal);
XMLString::catString(str,parts->elementAt(i));
}
}
}
//
// caller need to release the date created here
//
XMLDateTime* MonthDatatypeValidator::parse(const XMLCh* const content, MemoryManager* const manager)
{
XMLDateTime *pRetDate = new (manager) XMLDateTime(content, manager);
Janitor<XMLDateTime> jan(pRetDate);
try
{
pRetDate->parseMonth();
}
catch(const OutOfMemoryException&)
{
jan.release();
throw;
}
return jan.release();
}
XERCES_CPP_NAMESPACE_BEGIN
XMLCh* XMLBigInteger::getCanonicalRepresentation(const XMLCh* const rawData
, MemoryManager* const memMgr
, bool /* isNonPositiveInteger */)
{
try
{
XMLCh* retBuf = (XMLCh*) memMgr->allocate( (XMLString::stringLen(rawData) + 2) * sizeof(XMLCh));
ArrayJanitor<XMLCh> jan(retBuf, memMgr);
int sign = 0;
XMLBigInteger::parseBigInteger(rawData, retBuf, sign);
if (sign == 0)
{
retBuf[0] = chDigit_0;
retBuf[1] = chNull;
}
else if (sign == -1)
{
XMLCh* retBuffer = (XMLCh*) memMgr->allocate( (XMLString::stringLen(retBuf) + 2) * sizeof(XMLCh));
retBuffer[0] = chDash;
XMLString::copyString(&(retBuffer[1]), retBuf);
return retBuffer;
}
jan.release();
return retBuf;
}
catch (const NumberFormatException&)
{
return 0;
}
}
XMLByte* Base64::decode ( const XMLByte* const inputData
, XMLSize_t* decodedLength
, XMLByte*& canRepData
, MemoryManager* const memMgr
, Conformance conform
)
{
if ((!inputData) || (!*inputData))
return 0;
//
// remove all XML whitespaces from the base64Data
//
XMLSize_t inputLength = XMLString::stringLen( (const char*)inputData );
XMLByte* rawInputData = (XMLByte*) getExternalMemory(memMgr, (inputLength+1) * sizeof(XMLByte));
ArrayJanitor<XMLByte> jan(rawInputData, memMgr ? memMgr : XMLPlatformUtils::fgMemoryManager);
XMLSize_t inputIndex = 0;
XMLSize_t rawInputLength = 0;
bool inWhiteSpace = false;
switch (conform)
{
case Conf_RFC2045:
while ( inputIndex < inputLength )
{
if (!XMLChar1_0::isWhitespace(inputData[inputIndex]))
{
rawInputData[ rawInputLength++ ] = inputData[ inputIndex ];
}
// RFC2045 does not explicitly forbid more than ONE whitespace
// before, in between, or after base64 octects.
// Besides, S? allows more than ONE whitespace as specified in the production
// [3] S ::= (#x20 | #x9 | #xD | #xA)+
// therefore we do not detect multiple ws
inputIndex++;
}
break;
case Conf_Schema:
// no leading #x20
if (chSpace == inputData[inputIndex])
return 0;
while ( inputIndex < inputLength )
{
if (chSpace != inputData[inputIndex])
{
rawInputData[ rawInputLength++ ] = inputData[ inputIndex ];
inWhiteSpace = false;
}
else
{
if (inWhiteSpace)
return 0; // more than 1 #x20 encountered
else
inWhiteSpace = true;
}
inputIndex++;
}
// no trailing #x20
if (inWhiteSpace)
return 0;
break;
default:
break;
}
//now rawInputData contains canonical representation
//if the data is valid Base64
rawInputData[ rawInputLength ] = 0;
// the length of raw data should be divisible by four
if (( rawInputLength % FOURBYTE ) != 0 )
return 0;
int quadrupletCount = (int)rawInputLength / FOURBYTE;
if ( quadrupletCount == 0 )
return 0;
//
// convert the quadruplet(s) to triplet(s)
//
XMLByte d1, d2, d3, d4; // base64 characters
XMLByte b1, b2, b3, b4; // base64 binary codes ( 0..64 )
XMLSize_t rawInputIndex = 0;
XMLSize_t outputIndex = 0;
XMLByte *decodedData = (XMLByte*) getExternalMemory(memMgr, (quadrupletCount*3+1) * sizeof(XMLByte));
//
// Process all quadruplet(s) except the last
//
int quad = 1;
for (; quad <= quadrupletCount-1; quad++ )
{
// read quadruplet from the input stream
if (!isData( (d1 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d2 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d3 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d4 = rawInputData[ rawInputIndex++ ]) ))
{
// if found "no data" just return NULL
returnExternalMemory(memMgr, decodedData);
return 0;
}
b1 = base64Inverse[ d1 ];
b2 = base64Inverse[ d2 ];
b3 = base64Inverse[ d3 ];
b4 = base64Inverse[ d4 ];
// write triplet to the output stream
decodedData[ outputIndex++ ] = set1stOctet(b1, b2);
decodedData[ outputIndex++ ] = set2ndOctet(b2, b3);
decodedData[ outputIndex++ ] = set3rdOctet(b3, b4);
}
//
// process the last Quadruplet
//
// first two octets are present always, process them
if (!isData( (d1 = rawInputData[ rawInputIndex++ ]) ) ||
!isData( (d2 = rawInputData[ rawInputIndex++ ]) ))
{
// if found "no data" just return NULL
returnExternalMemory(memMgr, decodedData);
return 0;
}
b1 = base64Inverse[ d1 ];
b2 = base64Inverse[ d2 ];
// try to process last two octets
d3 = rawInputData[ rawInputIndex++ ];
d4 = rawInputData[ rawInputIndex++ ];
if (!isData( d3 ) || !isData( d4 ))
{
// check if last two are PAD characters
if (isPad( d3 ) && isPad( d4 ))
{
// two PAD e.g. 3c==
if ((b2 & 0xf) != 0) // last 4 bits should be zero
{
returnExternalMemory(memMgr, decodedData);
return 0;
}
decodedData[ outputIndex++ ] = set1stOctet(b1, b2);
}
else if (!isPad( d3 ) && isPad( d4 ))
{
// one PAD e.g. 3cQ=
b3 = base64Inverse[ d3 ];
if (( b3 & 0x3 ) != 0 ) // last 2 bits should be zero
{
returnExternalMemory(memMgr, decodedData);
return 0;
}
decodedData[ outputIndex++ ] = set1stOctet( b1, b2 );
decodedData[ outputIndex++ ] = set2ndOctet( b2, b3 );
}
else
{
// an error like "3c[Pad]r", "3cdX", "3cXd", "3cXX" where X is non data
returnExternalMemory(memMgr, decodedData);
return 0;
}
}
else
{
// no PAD e.g 3cQl
b3 = base64Inverse[ d3 ];
b4 = base64Inverse[ d4 ];
decodedData[ outputIndex++ ] = set1stOctet( b1, b2 );
decodedData[ outputIndex++ ] = set2ndOctet( b2, b3 );
decodedData[ outputIndex++ ] = set3rdOctet( b3, b4 );
}
// write out the end of string
decodedData[ outputIndex ] = 0;
*decodedLength = outputIndex;
//allow the caller to have access to the canonical representation
jan.release();
canRepData = rawInputData;
return decodedData;
}
// -----------------------------------------------------------------------
// Abstract interface from AbstractNumericValidator
// -----------------------------------------------------------------------
void DecimalDatatypeValidator::checkContent(const XMLCh* const content
, ValidationContext* const context
, bool asBase
, MemoryManager* const manager)
{
//validate against base validator if any
DecimalDatatypeValidator *pBase = (DecimalDatatypeValidator*) this->getBaseValidator();
if (pBase)
pBase->checkContent(content, context, true, manager);
int thisFacetsDefined = getFacetsDefined();
// we check pattern first
if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
{
// lazy construction
if (getRegex() ==0) {
try {
// REVISIT: cargillmem fMemoryManager vs manager
setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption, fMemoryManager));
}
catch (XMLException &e)
{
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::RethrowError, e.getMessage(), manager);
}
}
if (getRegex()->matches(content, manager) ==false)
{
ThrowXMLwithMemMgr2(InvalidDatatypeValueException
, XMLExcepts::VALUE_NotMatch_Pattern
, content
, getPattern()
, manager);
}
}
// if this is a base validator, we only need to check pattern facet
// all other facet were inherited by the derived type
if (asBase)
return;
XMLCh *errorMsg = 0;
try {
XMLBigDecimal compareDataValue(content, manager);
XMLBigDecimal* compareData = &compareDataValue;
if (getEnumeration())
{
int i=0;
int enumLength = getEnumeration()->size();
for ( ; i < enumLength; i++)
{
if (compareValues(compareData, (XMLBigDecimal*) getEnumeration()->elementAt(i)) ==0 )
break;
}
if (i == enumLength)
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
}
boundsCheck(compareData, manager);
if ( (thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0 )
{
if ( compareData->getScale() > fFractionDigits )
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(compareData->getScale(), value1, BUF_LEN, 10, manager);
XMLString::binToText(fFractionDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
, XMLExcepts::VALUE_exceed_fractDigit
, compareData->getRawData()
, value1
, value2
, manager);
}
}
if ( (thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0 )
{
if ( compareData->getTotalDigit() > fTotalDigits )
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(compareData->getTotalDigit(), value1, BUF_LEN, 10, manager);
XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
, XMLExcepts::VALUE_exceed_totalDigit
, compareData->getRawData()
, value1
, value2
, manager);
}
/***
E2-44 totalDigits
... by restricting it to numbers that are expressible as i � 10^-n
where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits.
***/
if ( compareData->getScale() > fTotalDigits )
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(compareData->getScale(), value1, BUF_LEN, 10, manager);
XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
, XMLExcepts::VALUE_exceed_totalDigit
, compareData->getRawData()
, value1
, value2
, manager);
}
}
}
catch (XMLException &e)
{
errorMsg = XMLString::replicate(e.getMessage(), manager);
}
if(errorMsg)
{
ArrayJanitor<XMLCh> jan(errorMsg, manager);
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::RethrowError, errorMsg, manager);
}
}
// ______________________________________________
void fzd2bin(const Int_t Nevents=5, const Char_t *fzfile ="muon.fzd",int socketID=9093) {
Int_t i=0;
gSystem->Load("EEmc.so");
gROOT->LoadMacro("bfc.C");
bfc(0,"fzin sim_T gen_T",fzfile);
#ifdef WRITE_SOCKET
cout<<"opening socket="<<socketID<<"\n";
TServerSocket *ss = new TServerSocket(socketID, kTRUE);
cout<<"waits for client1...\n";
// Accept a connection and return a full-duplex communication socket.
TSocket *s0 = ss->Accept();
cout<<"waits 2...\n";
#endif
for (i=1; i<=Nevents; i++ ) {
chain->Clear();
if (chain->Make(i)>=kStEOF) break;
printf("%2d ====================================\n",i);
St_g2t_ctf_hit *emc_hit = (St_g2t_ctf_hit *) chain->FindObject("g2t_eem_hit");
if (emc_hit==0) continue;
#ifdef WRITE_SOCKET// ...... use socket to transport data
cout<<"sending this event via socket ...\n";
// tell the clients to start
EEmcMCData data;
const int mx=1<<14;
char hitBuf[mx];
int nh = data.decode(emc_hit);
cerr << "actual hits " << nh << endl;
int nbw = ev->write(hitBuf,mx);
int ret=s0->SendRaw(hitBuf,nbw);
cout<<ret<<" char sent\n";
if(ret!=nbw) {
cerr<<"socekt Error1 "<<ret<<" "<<nbw<<endl;
}
#endif
#ifdef WRITE_FILE // ...... write events to bin file
static FILE *fd=0;
if(fd==0) {fd=fopen("data.bin","w"); assert(fd);}
EEmcMCData data;
const int mx=1<<14;
char hitBuf[mx];
int nh = data.decode(emc_hit);
cerr << "actual hits " << nh << endl;
int nbw = data->write(hitBuf,mx);
char *cnbw=&nbw;
int j;
for(j=0;j<sizeof(int);j++) fputc(cnbw[j],fd);
for(j=0;j<nbw;j++) fputc(hitBuf[j],fd);
#endif
// .............. do sth with data locally
EEuse1 jan(emc_hit);
jan.work();
}
}
