diff --git a/pvDataApp/factory/3058 b/pvDataApp/factory/3058 new file mode 100644 index 0000000..6c26c74 --- /dev/null +++ b/pvDataApp/factory/3058 @@ -0,0 +1,3584 @@ +/* Convert.cpp */ +#include +#include +#include +#include +#include "lock.h" +#include "pvIntrospect.h" +#include "pvData.h" +#include "convert.h" + +namespace epics { namespace pvData { + +static Convert* convert = 0; +static PVDataCreate* pvDataCreate = 0; + +static String trueString("true"); +static String falseString("false"); +static String logicError("Logic error. Should never get here."); +static String illegalScalarType("Illegal ScalarType"); + +static bool convertEquals(PVField *a,PVField *b); +static int convertFromByteArray(PVScalarArray *pv, int offset, + int len,int8 from[], int fromOffset); +static int convertToByteArray(PVScalarArray *pv, int offset, + int len,int8 to[], int toOffset); +static int convertFromShortArray(PVScalarArray *pv, int offset, + int len,int16 from[], int fromOffset); +static int convertToShortArray(PVScalarArray *pv, int offset, + int len,int16 to[], int toOffset); +static int convertFromIntArray(PVScalarArray *pv, int offset, + int len,int32 from[], int fromOffset); +static int convertToIntArray(PVScalarArray *pv, int offset, + int len,int32 to[], int toOffset); +static int convertFromLongArray(PVScalarArray *pv, int offset, + int len,int64 from[], int fromOffset); +static int convertToLongArray(PVScalarArray * pv, int offset, + int len,int64 to[], int toOffset); +static int convertFromFloatArray(PVScalarArray *pv, int offset, + int len,float from[], int fromOffset); +static int convertToFloatArray(PVScalarArray * pv, int offset, + int len,float to[], int toOffset); +static int convertFromDoubleArray(PVScalarArray *pv, int offset, + int len,double from[], int fromOffset); +static int convertToDoubleArray(PVScalarArray * pv, int offset, + int len,double to[], int toOffset); +static int convertFromStringArray(PVScalarArray *pv, int offset, + int len,String from[], int fromOffset); +static int convertToStringArray(PVScalarArray * pv, int offset, + int len,String to[], int toOffset); + +static void convertToString(StringBuilder buffer, + PVField * pv,int indentLevel); +static void convertStructure(StringBuilder buffer, + PVStructure *data,int indentLevel); +static void convertArray(StringBuilder buffer, + PVScalarArray * pv,int indentLevel); +static void convertStructureArray(StringBuilder buffer, + PVStructureArray * pvdata,int indentLevel); +static int copyArrayDataReference(PVScalarArray *from,PVArray *to); +static int copyNumericArray(PVScalarArray *from, + int offset, PVScalarArray *to, int toOffset, int len); + +static std::vector split(String commaSeparatedList); + +static std::vector split(String commaSeparatedList) { + String::size_type numValues = 1; + String::size_type index=0; + while(true) { + String::size_type pos = commaSeparatedList.find(',',index); + if(pos==String::npos) break; + numValues++; + index = pos +1; + } + std::vector valueList(numValues,""); + index=0; + for(size_t i=0; iempty(); + *buf += pvField->getField()->getFieldName(); + PVStructure *parent; + while((parent=pvField->getParent())!=0) { + pvField = pvField->getParent(); + String name = pvField->getField()->getFieldName(); + if(name.length()>0) { + buf->insert(0,"."); + buf->insert(0,name); + } + } +} + +bool Convert::equals(PVField *a,PVField *b) +{ + return convertEquals(a,b); +} + +void Convert::getString(StringBuilder buf,PVField * pvField,int indentLevel) +{ + convertToString(buf,pvField,indentLevel); +} + +void Convert::getString(StringBuilder buf,PVField * pvField) +{ + convertToString(buf,pvField,0); +} + +void Convert::fromString(PVScalar *pvScalar, String from) +{ + ScalarConstPtr scalar = pvScalar->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: { + PVBoolean *pv = (PVBoolean *)pvScalar; + bool value = + ((from.compare("true")==0) ? true : false); + pv->put(value); + return; + } + case pvByte : { + PVByte *pv = (PVByte*)pvScalar; + int ival; + sscanf(from.c_str(),"%d",&ival); + int8 value = ival; + pv->put(value); + return; + } + case pvShort : { + PVShort *pv = (PVShort*)pvScalar; + int ival; + sscanf(from.c_str(),"%d",&ival); + int16 value = ival; + pv->put(value); + return; + } + case pvInt : { + PVInt *pv = (PVInt*)pvScalar; + int ival; + sscanf(from.c_str(),"%d",&ival); + int32 value = ival; + pv->put(value); + return; + } + case pvLong : { + PVLong *pv = (PVLong*)pvScalar; + int64 ival; + sscanf(from.c_str(),"%lld",&ival); + int64 value = ival; + pv->put(value); + return; + } + case pvFloat : { + PVFloat *pv = (PVFloat*)pvScalar; + float value; + sscanf(from.c_str(),"%f",&value); + pv->put(value); + return; + } + case pvDouble : { + PVDouble*pv = (PVDouble*)pvScalar; + double value; + sscanf(from.c_str(),"%lf",&value); + pv->put(value); + return; + } + case pvString: { + PVString *value = (PVString*)pvScalar; + value->put(from); + return; + } + } + String message("Convert::fromString unknown scalarType "); + ScalarTypeFunc::toString(&message,scalarType); + throw std::logic_error(message); +} + +int Convert::fromString(PVScalarArray *pv, String from) +{ + if(from[0]=='[' && from[from.length()]==']') { + int offset = from.rfind(']'); + from = from.substr(1, offset); + } + std::vector valueList = split(from); + int length = valueList.size(); + StringArray valueArray = new String[length]; + for(int i=0; isetLength(length); + delete[] valueArray; + return length; +} + +int Convert::fromStringArray(PVScalarArray *pv, int offset, int length, + String from[], int fromOffset) +{ + return convertFromStringArray(pv,offset,length,from,fromOffset); +} + +int Convert::toStringArray(PVScalarArray * pv, int offset, int length, + String to[], int toOffset) +{ + return convertToStringArray(pv,offset,length,to,toOffset); +} + +bool Convert::isCopyCompatible(FieldConstPtr from, FieldConstPtr to) +{ + if(from->getType()!=to->getType()) return false; + switch(from->getType()) { + case scalar: + return isCopyScalarCompatible((ScalarConstPtr)from,(ScalarConstPtr)to); + case scalarArray: + return isCopyScalarArrayCompatible((ScalarArrayConstPtr)from,(ScalarArrayConstPtr)to); + case structure: + return isCopyStructureCompatible((StructureConstPtr)from,(StructureConstPtr)to); + case structureArray: + return isCopyStructureArrayCompatible((StructureArrayConstPtr)from,(StructureArrayConstPtr)to); + } + String message("Convert::isCopyCompatible should never get here"); + throw std::logic_error(message); +} + +void Convert::copy(PVField *from,PVField *to) +{ + switch(from->getField()->getType()) { + case scalar: + copyScalar((PVScalar *)from,(PVScalar *)to); + return; + case scalarArray: { + PVScalarArray *fromArray = (PVScalarArray *)from; + PVScalarArray *toArray = (PVScalarArray *)to; + int length = copyScalarArray(fromArray,0,toArray,0,fromArray->getLength()); + if(toArray->getLength()!=length) toArray->setLength(length); + return; + } + case structure: + copyStructure((PVStructure *)from,(PVStructure *)to); + return; + case structureArray: { + PVStructureArray *fromArray = (PVStructureArray *)from; + PVStructureArray *toArray = (PVStructureArray *)to; + copyStructureArray(fromArray,toArray); + return; + } + } +} + +bool Convert::isCopyScalarCompatible( + ScalarConstPtr fromField, ScalarConstPtr toField) +{ + ScalarType fromScalarType = fromField->getScalarType(); + ScalarType toScalarType = toField->getScalarType(); + if(fromScalarType==toScalarType) return true; + if(ScalarTypeFunc::isNumeric(fromScalarType) + && ScalarTypeFunc::isNumeric(toScalarType)) return true; + if(fromScalarType==pvString) return true; + if(toScalarType==pvString) return true; + return false; +} + +void Convert::copyScalar(PVScalar *from, PVScalar *to) +{ + if(to->isImmutable()) { + if(from==to) return; + String message("Convert.copyScalar destination is immutable"); + throw std::invalid_argument(message); + } + ScalarType fromType = from->getScalar()->getScalarType(); + ScalarType toType = to->getScalar()->getScalarType(); + switch(fromType) { + case pvBoolean: { + if(toType!=pvBoolean) { + if(toType!=pvString) { + String message("Convert.copyScalar arguments are not compatible"); + throw std::invalid_argument(message); + } + } + PVBoolean *data = (PVBoolean*)from; + if(toType==pvString) { + PVString *dataTo = (PVString*)to; + String buf(""); + data->toString(&buf); + dataTo->put(buf); + } else { + bool value = data->get(); + PVBoolean *dataTo = (PVBoolean*)to; + dataTo->put(value); + } + break; + } + case pvByte : { + PVByte *data = (PVByte*)from; + int8 value = data->get(); + convert->fromByte(to,value); + break; + } + case pvShort : { + PVShort *data = (PVShort*)from; + short value = data->get(); + convert->fromShort(to,value); + break; + } + case pvInt :{ + PVInt *data = (PVInt*)from; + int value = data->get(); + convert->fromInt(to,value); + break; + } + case pvLong : { + PVLong *data = (PVLong*)from; + long value = data->get(); + convert->fromLong(to,value); + break; + } + case pvFloat : { + PVFloat *data = (PVFloat*)from; + float value = data->get(); + convert->fromFloat(to,value); + break; + } + case pvDouble : { + PVDouble *data = (PVDouble*)from; + double value = data->get(); + convert->fromDouble(to,value); + break; + } + case pvString: { + PVString *data = (PVString*)from; + String value = data->get(); + convert->fromString(to,value); + break; + } + } + String message("Convert::copyScalar should never get here"); + throw std::logic_error(message); +} + +bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr fromArray, + ScalarArrayConstPtr toArray) +{ + ScalarType fromType = fromArray->getElementType(); + ScalarType toType = toArray->getElementType(); + if(fromType==toType) return true; + if(ScalarTypeFunc::isNumeric(fromType) + && ScalarTypeFunc::isNumeric(toType)) return true; + if(toType==pvString) return true; + if(fromType==pvString) return true; + return false; +} + +int Convert::copyScalarArray(PVScalarArray *from, int offset, + PVScalarArray *to, int toOffset, int length) +{ + if(to->isImmutable()) { + if(from==to) return from->getLength(); + String message("Convert.copyArray destination is immutable"); + throw std::invalid_argument(message); + } + ScalarType fromElementType = from->getScalarArray()->getElementType(); + ScalarType toElementType = to->getScalarArray()->getElementType(); + + if(from->isImmutable() && (fromElementType==toElementType)) { + if(offset==0 && toOffset==0 && length==from->getLength()) { + return copyArrayDataReference(from,to); + } + } + + int ncopy = 0; + if(ScalarTypeFunc::isNumeric(fromElementType) + && ScalarTypeFunc::isNumeric(toElementType)) { + return copyNumericArray(from,offset,to,toOffset,length); + } else if(toElementType==pvBoolean && fromElementType==pvBoolean) { + PVBooleanArray *pvfrom = (PVBooleanArray*)from; + PVBooleanArray *pvto = (PVBooleanArray*)to; + while(length>0) { + int num = 0; + BooleanArray data = 0; + int fromOffset = 0; + BooleanArrayData booleanArrayData = BooleanArrayData(); + num = pvfrom->get(offset,length,&booleanArrayData); + data = booleanArrayData.data; + fromOffset = booleanArrayData.offset; + if(num<=0) return ncopy; + while(num>0) { + int n = pvto->put(toOffset,num,data,fromOffset); + if(n<=0) return ncopy; + length -= n; num -= n; ncopy+=n; offset += n; toOffset += n; + } + } + } else if(toElementType==pvString && fromElementType==pvString) { + PVStringArray *pvfrom = (PVStringArray*)from; + PVStringArray *pvto = (PVStringArray*)to; + while(length>0) { + int num = 0; + String *data; + int fromOffset = 0; + StringArrayData stringArrayData = StringArrayData(); + num = pvfrom->get(offset,length,&stringArrayData); + data = stringArrayData.data; + fromOffset = stringArrayData.offset; + if(num<=0) return ncopy; + while(num>0) { + int n = pvto->put(toOffset,num,data,fromOffset); + if(n<=0) return ncopy; + length -= n; num -= n; ncopy+=n; offset += n; toOffset += n; + } + } + } else if(toElementType==pvString) { + PVStringArray *pvto = (PVStringArray*)to; + ncopy = from->getLength(); + if(ncopy>length) ncopy = length; + int num = ncopy; + String toData[1]; + while(num>0) { + convert->toStringArray(from,offset,1,toData,0); + if(pvto->put(toOffset,1,toData,0)<=0) break; + num--; offset++; toOffset++; + } + return ncopy; + } else if(fromElementType==pvString) { + PVStringArray *pvfrom = (PVStringArray*)from; + while(length>0) { + int num = 0; + String *data = 0; + int fromOffset = 0; + StringArrayData stringArrayData = StringArrayData(); + num = pvfrom->get(offset,length,&stringArrayData); + data = stringArrayData.data; + fromOffset = stringArrayData.offset; + if(num<=0) return ncopy; + while(num>0) { + int n = fromStringArray(to,toOffset,num,data,fromOffset); + if(n<=0) return ncopy; + length -= n; num -= n; ncopy+=n; offset += n; toOffset += n; + } + } + } + String message("Convert::copyScalarArray should not get here"); + throw std::logic_error(message); +} + +bool Convert::isCopyStructureCompatible( + StructureConstPtr fromStruct, StructureConstPtr toStruct) +{ + FieldConstPtrArray fromFields = fromStruct->getFields(); + FieldConstPtrArray toFields = toStruct->getFields(); + int length = fromStruct->getNumberFields(); + if(length!=toStruct->getNumberFields()) return false; + for(int i=0; igetType(); + Type toType = to->getType(); + if(fromType!=toType) return false; + switch(fromType) { + case scalar: + if(!convert->isCopyScalarCompatible((ScalarConstPtr)from,(ScalarConstPtr)to)) return false; + break; + case scalarArray: + if(!isCopyScalarArrayCompatible((ScalarArrayConstPtr)from,(ScalarArrayConstPtr)to)) + return false; + break; + case structure: + if(!isCopyStructureCompatible((StructureConstPtr)from,(StructureConstPtr)to)) + return false; + break; + case structureArray: + if(!isCopyStructureArrayCompatible((StructureArrayConstPtr)from, + (StructureArrayConstPtr)to)) return false; + } + } + return true; +} + +void Convert::copyStructure(PVStructure *from, PVStructure *to) +{ + if(to->isImmutable()) { + if(from==to) return; + String message("Convert.copyStructure destination is immutable"); + throw std::invalid_argument(message); + } + if(from==to) return; + PVFieldPtrArray fromDatas = from->getPVFields(); + PVFieldPtrArray toDatas = to->getPVFields(); + if(from->getStructure()->getNumberFields() + != to->getStructure()->getNumberFields()) { + String message("Convert.copyStructure Illegal copyStructure"); + throw std::invalid_argument(message); + } + int numberFields = from->getStructure()->getNumberFields(); + if(numberFields==2) { + // look for enumerated structure and copy choices first + String fieldName = fromDatas[0]->getField()->getFieldName(); + if(fieldName.compare("index")==0) { + FieldConstPtr fieldIndex = fromDatas[0]->getField(); + FieldConstPtr fieldChoices = fromDatas[1]->getField(); + if(fieldIndex->getType()==scalar + && fieldChoices->getFieldName().compare("choices") + && fieldChoices->getType()==scalarArray) { + PVScalar *pvScalar = (PVScalar*)fromDatas[0]; + PVScalarArray *pvArray = (PVScalarArray*)fromDatas[1]; + if((pvScalar->getScalar()->getScalarType()==pvInt) + && (pvArray->getScalarArray()->getElementType()==pvString)) { + PVScalarArray* toArray = (PVScalarArray*)toDatas[1]; + copyScalarArray(pvArray,0,toArray,0,pvArray->getLength()); + PVScalar *toScalar = (PVScalar*)toDatas[0]; + copyScalar(pvScalar,toScalar); + return; + } + } + } + } + for(int i=0; i < numberFields; i++) { + PVField *fromData = fromDatas[i]; + PVField *toData = toDatas[i]; + Type fromType = fromData->getField()->getType(); + Type toType = toData->getField()->getType(); + if(fromType!=toType) { + String message("Convert.copyStructure Illegal copyStructure"); + throw std::invalid_argument(message); + } + switch(fromType) { + case scalar: + copyScalar((PVScalar*)fromData,(PVScalar*)toData); + break; + case scalarArray: { + PVScalarArray *fromArray = (PVScalarArray*)fromData; + PVScalarArray *toArray = (PVScalarArray*)toData; + int length = copyScalarArray(fromArray,0,toArray,0,fromArray->getLength()); + if(toArray->getLength()!=length) toArray->setLength(length); + break; + } + case structure: + copyStructure((PVStructure*)fromData,(PVStructure*)toData); + break; + case structureArray: { + PVStructureArray *fromArray = (PVStructureArray*)fromData; + PVStructureArray *toArray = (PVStructureArray*)toData; + copyStructureArray(fromArray,toArray); + break; + } + } + } +} + +bool Convert::isCopyStructureArrayCompatible( + StructureArrayConstPtr from, StructureArrayConstPtr to) +{ + return isCopyStructureCompatible(from->getStructure(),to->getStructure()); +} + +void Convert::copyStructureArray( + PVStructureArray *from, PVStructureArray *to) +{ + if(to->isImmutable()) { + if(from==to) return; + String message("Convert.copyStructureArray destination is immutable"); + throw std::invalid_argument(message); + } + if(!isCopyStructureCompatible( + from->getStructureArray()->getStructure(), + to->getStructureArray()->getStructure())) { + String message("Convert.copyStructureArray from and to are not compatible"); + throw std::invalid_argument(message); + } + PVStructurePtrArray fromArray = 0; + int length = from->getLength(); + StructureArrayData structureArrayData = StructureArrayData(); + from->get(0, length,&structureArrayData); + fromArray = structureArrayData.data; + PVStructurePtrArray toArray = 0; + if(to->getCapacity()setCapacity(length); + to->get(0, length,&structureArrayData); + toArray = structureArrayData.data; + for(int i=0; igetStructureArray()->getStructure(); + toArray[i] = pvDataCreate->createPVStructure(0,structure); + } + copyStructure(fromArray[i],toArray[i]); + } + } + to->setLength(length); + to->postPut(); +} + +int8 Convert::toByte(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to byte")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to byte")); + } + throw std::logic_error(logicError); +} + +int16 Convert::toShort(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to short")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to short")); + } + throw std::logic_error(logicError); +} + +int32 Convert::toInt(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to int")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to int")); + } + throw std::logic_error(logicError); +} + +int64 Convert::toLong(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to long")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to long")); + } + throw std::logic_error(logicError); +} + +float Convert::toFloat(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to float")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to float")); + } + throw std::logic_error(logicError); +} + +double Convert::toDouble(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to double")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to double")); + } + throw std::logic_error(logicError); +} + +void Convert::fromByte(PVScalar *pv,int8 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("byte can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int ival = from; + sprintf(buffer,"%d",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromShort(PVScalar *pv,int16 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("short can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int ival = from; + sprintf(buffer,"%d",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromInt(PVScalar *pv, int32 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("int can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int ival = from; + sprintf(buffer,"%d",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromLong(PVScalar *pv, int64 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("long can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int64 ival = from; + sprintf(buffer,"%lld",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromFloat(PVScalar* pv, float from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("float can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + double dval = from; + sprintf(buffer,"%g",dval); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromDouble(PVScalar *pv, double from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("double can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + double dval = from; + sprintf(buffer,"%g",dval); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +int Convert::toByteArray(PVScalarArray * pv, int offset, int length, + int8 to[], int toOffset) +{ + return convertToByteArray(pv, offset, length, to, toOffset); +} + +int Convert::toShortArray(PVScalarArray * pv, int offset, int length, + int16 to[], int toOffset) +{ + return convertToShortArray(pv, offset, length, to, toOffset); +} + +int Convert::toIntArray(PVScalarArray * pv, int offset, int length, + int32 to[], int toOffset) +{ + return convertToIntArray(pv, offset, length, to, toOffset); +} + +int Convert::toLongArray(PVScalarArray * pv, int offset, int length, + int64 to[], int toOffset) +{ + return convertToLongArray(pv, offset, length, to, toOffset); +} + +int Convert::toFloatArray(PVScalarArray * pv, int offset, int length, + float to[], int toOffset) +{ + return convertToFloatArray(pv, offset, length, to, toOffset); +} + +int Convert::toDoubleArray(PVScalarArray * pv, int offset, int length, + double to[], int toOffset) +{ + return convertToDoubleArray(pv, offset, length, to, toOffset); +} + +int Convert::fromByteArray(PVScalarArray *pv, int offset, int length, + int8 from[], int fromOffset) +{ + return convertFromByteArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromShortArray(PVScalarArray *pv, int offset, int length, + int16 from[], int fromOffset) +{ + return convertFromShortArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromIntArray(PVScalarArray *pv, int offset, int length, + int32 from[], int fromOffset) +{ + return convertFromIntArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromLongArray(PVScalarArray *pv, int offset, int length, + int64 from[], int fromOffset) +{ + return convertFromLongArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromFloatArray(PVScalarArray *pv, int offset, int length, + float from[], int fromOffset) +{ + return convertFromFloatArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromDoubleArray(PVScalarArray *pv, int offset, int length, + double from[], int fromOffset) +{ + return convertFromDoubleArray(pv, offset, length, from, fromOffset); +} + +void Convert::newLine(StringBuilder buffer, int indentLevel) +{ + *buffer += "\n"; + for(int i=0; igetScalar()->getScalarType(); + ScalarType bscalarType = b->getScalar()->getScalarType(); + if(ascalarType!=bscalarType) return false; + switch(ascalarType) { + case pvBoolean: { + PVBoolean *pa = (PVBoolean *)a; + PVBoolean *pb = (PVBoolean *)b; + bool avalue = pa->get(); + bool bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvByte: { + PVByte *pa = (PVByte *)a; + PVByte *pb = (PVByte *)b; + int8 avalue = pa->get(); + int8 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvShort: { + PVShort *pa = (PVShort *)a; + PVShort *pb = (PVShort *)b; + int16 avalue = pa->get(); + int16 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvInt: { + PVInt *pa = (PVInt *)a; + PVInt *pb = (PVInt *)b; + int32 avalue = pa->get(); + int32 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvLong: { + PVLong *pa = (PVLong *)a; + PVLong *pb = (PVLong *)b; + int64 avalue = pa->get(); + int64 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvFloat: { + PVFloat *pa = (PVFloat *)a; + PVFloat *pb = (PVFloat *)b; + float avalue = pa->get(); + float bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvDouble: { + PVDouble *pa = (PVDouble *)a; + PVDouble *pb = (PVDouble *)b; + double avalue = pa->get(); + double bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvString: { + PVString *pa = (PVString *)a; + PVString *pb = (PVString *)b; + String avalue = pa->get(); + String bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + } + String message("should not get here"); + throw std::logic_error(message); +} + +static bool arrayEquals(PVScalarArray *a,PVScalarArray *b) +{ + if(a==b) return true; + ScalarType aType = a->getScalarArray()->getElementType(); + ScalarType bType = b->getScalarArray()->getElementType(); + if(aType!=bType) return false; + if(a->getLength()!=b->getLength()) return false; + int length = a->getLength(); + switch(aType) { + case pvBoolean: { + PVBooleanArray *aarray = (PVBooleanArray *)a; + PVBooleanArray *barray = (PVBooleanArray *)b; + BooleanArrayData adata = BooleanArrayData(); + BooleanArrayData bdata = BooleanArrayData(); + aarray->get(0,length,&adata); + barray->get(0,length,&bdata); + BooleanArray avalue = adata.data; + BooleanArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + ByteArray avalue = adata.data; + ByteArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + ShortArray avalue = adata.data; + ShortArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + IntArray avalue = adata.data; + IntArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + LongArray avalue = adata.data; + LongArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + FloatArray avalue = adata.data; + FloatArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + DoubleArray avalue = adata.data; + DoubleArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + String *avalue = adata.data; + String *bvalue = bdata.data; + for(int i=0; igetStructureArray()->getStructure(); + StructureConstPtr bStructure = b->getStructureArray()->getStructure(); + if(aStructure!=bStructure) return false; + if(a->getLength()!=b->getLength()) return false; + StructureArrayData aData = StructureArrayData(); + StructureArrayData bData = StructureArrayData(); + int length = a->getLength(); + PVStructurePtrArray aArray = aData.data; + PVStructurePtrArray bArray = bData.data; + if(aArray==bArray) return true; + for(int i=0; igetStructure(); + StructureConstPtr bStructure = a->getStructure(); + int length = aStructure->getNumberFields(); + if(length!=bStructure->getNumberFields()) return false; + PVFieldPtrArray aFields = a->getPVFields(); + PVFieldPtrArray bFields = b->getPVFields(); + for(int i=0; igetField()->getType(); + Type btype = b->getField()->getType(); + if(atype!=btype) return false; + if(atype==scalar) return scalarEquals((PVScalar *)a,(PVScalar *)b); + if(atype==scalarArray) { + return arrayEquals((PVScalarArray *)a,(PVScalarArray *)b); + } + if(atype==structureArray) { + return structureArrayEquals( + (PVStructureArray *)a,(PVStructureArray *)b); + } + if(atype==structure) { + return structureEquals((PVStructure *)a,(PVStructure *)b); + } + String message("should not get here"); + throw std::logic_error(message); +} + +int convertFromByteArray(PVScalarArray *pv, int offset, int len,int8 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from byte[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from byte[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromByteArray should never get here"); + throw std::logic_error(message); +} + +int convertToByteArray(PVScalarArray * pv, int offset, int len,int8 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to byte[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to byte[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToByteArray should never get here"); + throw std::logic_error(message); +} + +int convertFromShortArray(PVScalarArray *pv, int offset, int len,int16 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from short[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from short[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromShortArray should never get here"); + throw std::logic_error(message); +} + +int convertToShortArray(PVScalarArray * pv, int offset, int len,int16 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to short[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to short[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToShortArray should never get here"); + throw std::logic_error(message); +} + +int convertFromIntArray(PVScalarArray *pv, int offset, int len,int32 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from int[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from int[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromIntArray should never get here"); + throw std::logic_error(message); +} + +int convertToIntArray(PVScalarArray * pv, int offset, int len,int32 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to byte[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to int[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToIntArray should never get here"); + throw std::logic_error(message); +} + +int convertFromLongArray(PVScalarArray *pv, int offset, int len,int64 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from long[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from long[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromLongArray should never get here"); + throw std::logic_error(message); +} + +int convertToLongArray(PVScalarArray * pv, int offset, int len,int64 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to long[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to long[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToLongArray should never get here"); + throw std::logic_error(message); +} + +int convertFromFloatArray(PVScalarArray *pv, int offset, int len,float from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from float[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from float[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromFloatArray should never get here"); + throw std::logic_error(message); +} + +int convertToFloatArray(PVScalarArray * pv, int offset, int len,float to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to float[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to float[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToFloatArray should never get here"); + throw std::logic_error(message); +} + +int convertFromDoubleArray(PVScalarArray *pv, int offset, int len,double from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from double[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvString: { + String message("convert from double[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromDoubleArray should never get here"); + throw std::logic_error(message); +} + +int convertToDoubleArray(PVScalarArray * pv, int offset, int len,double to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to float[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to double[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToDoubleArray should never get here"); + throw std::logic_error(message); +} + +int convertFromStringArray(PVScalarArray *pv, int offset, int len,String from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + PVBooleanArray *pvdata = (PVBooleanArray*) pv; + bool data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + data[0] = (fromString.compare("true")==0) ? true : false; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int ival; + sscanf(fromString.c_str(),"%d",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int ival; + sscanf(fromString.c_str(),"%d",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int ival; + sscanf(fromString.c_str(),"%d",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int64 ival; + sscanf(fromString.c_str(),"%lld",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + float fval; + sscanf(fromString.c_str(),"%f",&fval); + data[0] = fval; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + double fval; + sscanf(fromString.c_str(),"%lf",&fval); + data[0] = fval; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: + PVStringArray *pvdata = (PVStringArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + String message("Convert::convertFromStringArray should never get here"); + throw std::logic_error(message); +} + +int convertToStringArray(PVScalarArray * pv, int offset, int len,String to[], int toOffset) +{ + ScalarType elementType = pv->getScalarArray()->getElementType(); + int ncopy = pv->getLength(); + if (ncopy > len) ncopy = len; + int num = ncopy; + switch (elementType) { + case pvBoolean: { + PVBooleanArray *pvdata = (PVBooleanArray*) pv; + BooleanArrayData data = BooleanArrayData(); + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + BooleanArray dataArray = data.data; + bool value = dataArray[data.offset]; + to[toOffset + i] = value ? trueString : falseString; + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + ByteArray dataArray = data.data; + int ival = dataArray[data.offset]; + sprintf(cr,"%d",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + ShortArrayData data = ShortArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + ShortArray dataArray = data.data; + int ival = dataArray[data.offset]; + sprintf(cr,"%d",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + IntArray dataArray = data.data; + int ival = dataArray[data.offset]; + sprintf(cr,"%d",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + LongArray dataArray = data.data; + int64 ival = dataArray[data.offset]; + sprintf(cr,"%lld",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + FloatArray dataArray = data.data; + float fval = dataArray[data.offset]; + sprintf(cr,"%g",fval); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + DoubleArray dataArray = data.data; + double fval = dataArray[data.offset]; + sprintf(cr,"%g",fval); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvString: { + PVStringArray *pvdata = (PVStringArray*) pv; + while (num > 0) { + int numnow = 0; + StringArray dataArray = 0; + int dataOffset = 0; + StringArrayData stringArrayData = StringArrayData(); + numnow = pvdata->get(offset, num, &stringArrayData); + dataArray = stringArrayData.data; + dataOffset = stringArrayData.offset; + if (numnow <= 0) { + for (int i = 0; i < num; i++) + to[toOffset + i] = "bad pv"; + break; + } + for(int i=0; igetField()->getType(); + if(type==scalarArray) { + return convertArray(buffer,(PVScalarArray *)pv,indentLevel); + } + if(type==structure) { + return convertStructure(buffer,(PVStructure*)pv,indentLevel); + } + if(type==structureArray) { + return convertStructureArray(buffer,(PVStructureArray*)pv,indentLevel); + } + ScalarConstPtr pscalar = pvScalar->getScalar(); + ScalarType scalarType = pscalar->getScalarType(); + ScalarTypeFunction::toString(buffer,scalarType); + *buffer += " "; + *buffer += scalar->getFieldName(); + PVScalar *pvScalar = (PVScalar*)pv; + *buffer += " "; + switch(scalarType) { + case pvBoolean: { + PVBoolean *data = (PVBoolean*)pv; + bool value = data->get(); + if(value) { + *buffer += "true"; + } else { + *buffer += "false"; + } + } + return; + case pvByte: { + PVByte *data = (PVByte*)pv; + char xxx[30]; + sprintf(xxx,"%d",(int)data->get()); + *buffer += xxx; + } + return; + case pvShort: { + PVShort *data = (PVShort*)pv; + char xxx[30]; + sprintf(xxx,"%d",(int)data->get()); + *buffer += xxx; + } + return; + case pvInt: { + PVInt *data = (PVInt*)pv; + char xxx[30]; + sprintf(xxx,"%d",(int)data->get()); + *buffer += xxx; + } + return; + case pvLong: { + PVLong *data = (PVLong*)pv; + char xxx[30]; + sprintf(xxx,"%lld",(int64)data->get()); + *buffer += xxx; + } + return; + case pvFloat: { + PVFloat *data = (PVFloat*)pv; + char xxx[30]; + sprintf(xxx,"%g",data->get()); + *buffer += xxx; + } + return; + case pvDouble: { + PVDouble *data = (PVDouble*)pv; + char xxx[30]; + sprintf(xxx,"%lg",data->get()); + *buffer += xxx; + } + return; + case pvString: { + PVString *data = (PVString*)pv; + *buffer += data->get(); + } + return; + default: + *buffer += "unknown ScalarType"; + } +} + +void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel) +{ + convert->newLine(buffer, indentLevel); + *buffer += "structure {"; + PVFieldPtrArray fieldsData = data->getPVFields(); + if (fieldsData != 0) { + int length = data->getStructure()->getNumberFields(); + for(int i=0; igetField(); + convert->newLine(buffer, indentLevel + 1); + int size = fieldnow->getFieldName().length(); + char buff[size+2]; + sprintf(buff,"%s = ",fieldnow->getFieldName().c_str()); + *buffer += buff; + convert->getString(buffer,fieldField,indentLevel + 1); + } + } + convert->newLine(buffer, indentLevel); + *buffer += "}"; +} + +void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel) +{ + ScalarArrayConstPtr array = pv->getScalarArray(); + ScalarType type = array->getElementType(); + switch(type) { + case pvBoolean: { + PVBooleanArray *pvdata = (PVBooleanArray*)pv; + BooleanArrayData data = BooleanArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ","; + int num = pvdata->get(i,1,&data); + if(num==1) { + BooleanArray value = data.data; + if(value[data.offset]) { + *buffer += "true"; + } else { + *buffer += "false"; + } + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*)pv; + ByteArrayData data = ByteArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ","; + int num = pvdata->get(i,1,&data); + if(num==1) { + int val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%d",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*)pv; + ShortArrayData data = ShortArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + int val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%d",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*)pv; + IntArrayData data = IntArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + int val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%d",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*)pv; + LongArrayData data = LongArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + int64 val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%lld",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*)pv; + FloatArrayData data = FloatArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + float val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%g",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*)pv; + DoubleArrayData data = DoubleArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + double val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%lg",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += ("]"); + break; + } + case pvString: { + PVStringArray *pvdata = (PVStringArray*)pv; + StringArrayData data = StringArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ","; + int num = pvdata->get(i,1,&data); + StringPtrArray value = data.data; + if(num==1) { + if(value[data.offset].length()>0) { + *buffer += value[data.offset].c_str(); + } else { + *buffer += "null"; + } + } else { + *buffer += "null"; + } + } + *buffer += "]"; + break; + } + default: + *buffer += " array element is unknown ScalarType"; + } + if(pv->isImmutable()) { + *buffer += " immutable "; + } +} + +void convertStructureArray(StringBuilder buffer, + PVStructureArray * pvdata,int indentLevel) +{ + StructureArrayData data = StructureArrayData(); + int length = pvdata->getLength(); + pvdata->get(0, length, &data); + *buffer += "["; + for (int i = 0; i < length; i++) { + if (i != 0) { + *buffer += ","; + } + convert->newLine(buffer, indentLevel + 1); + PVStructure *pvStructure = data.data[i]; + if (pvStructure == 0) { + *buffer += "null"; + } else { + pvStructure->toString(buffer,indentLevel+1); + } + } + convert->newLine(buffer, indentLevel); + *buffer += "]"; +} + +int copyArrayDataReference(PVScalarArray *from,PVArray *to) +{ + ScalarType scalarType = from->getScalarArray()->getElementType(); + switch (scalarType) { + case pvBoolean: { + PVBooleanArray *pvfrom = (PVBooleanArray*) from; + PVBooleanArray *pvto = (PVBooleanArray*) to; + BooleanArrayData booleanArrayData = BooleanArrayData(); + pvfrom->get(0, pvfrom->getLength(), &booleanArrayData); + BooleanArray booleanArray = booleanArrayData.data; + pvto->shareData(booleanArray,from->getCapacity(),from->getLength()); + break; + } + case pvByte: { + PVByteArray *pvfrom = (PVByteArray*) from; + PVByteArray *pvto = (PVByteArray*) to; + ByteArrayData byteArrayData = ByteArrayData(); + pvfrom->get(0, pvfrom->getLength(), &byteArrayData); + ByteArray byteArray = byteArrayData.data; + pvto->shareData(byteArray,from->getCapacity(),from->getLength()); + break; + } + case pvShort: { + PVShortArray *pvfrom = (PVShortArray*) from; + PVShortArray *pvto = (PVShortArray*) to; + ShortArrayData shortArrayData = ShortArrayData(); + pvfrom->get(0, pvfrom->getLength(), &shortArrayData); + ShortArray shortArray = shortArrayData.data; + pvto->shareData(shortArray,from->getCapacity(),from->getLength()); + break; + } + case pvInt: { + PVIntArray *pvfrom = (PVIntArray*) from; + PVIntArray *pvto = (PVIntArray*) to; + IntArrayData intArrayData = IntArrayData(); + pvfrom->get(0, pvfrom->getLength(), &intArrayData); + IntArray intArray = intArrayData.data; + pvto->shareData(intArray,from->getCapacity(),from->getLength()); + break; + } + case pvLong: { + PVLongArray *pvfrom = (PVLongArray*) from; + PVLongArray *pvto = (PVLongArray*) to; + LongArrayData longArrayData = LongArrayData(); + pvfrom->get(0, pvfrom->getLength(), &longArrayData); + LongArray longArray = longArrayData.data; + pvto->shareData(longArray,from->getCapacity(),from->getLength()); + break; + } + case pvFloat: { + PVFloatArray *pvfrom = (PVFloatArray*) from; + PVFloatArray *pvto = (PVFloatArray*) to; + FloatArrayData longArrayData = FloatArrayData(); + pvfrom->get(0, pvfrom->getLength(), &longArrayData); + FloatArray longArray = longArrayData.data; + pvto->shareData(longArray,from->getCapacity(),from->getLength()); + break; + } + case pvDouble: { + PVDoubleArray *pvfrom = (PVDoubleArray*) from; + PVDoubleArray *pvto = (PVDoubleArray*) to; + DoubleArrayData doubleArrayData = DoubleArrayData(); + pvfrom->get(0, pvfrom->getLength(), &doubleArrayData); + DoubleArray doubleArray = doubleArrayData.data; + pvto->shareData(doubleArray,from->getCapacity(),from->getLength()); + break; + } + case pvString: { + PVStringArray *pvfrom = (PVStringArray*) from; + PVStringArray *pvto = (PVStringArray*) to; + StringArrayData stringArrayData = StringArrayData(); + pvfrom->get(0, pvfrom->getLength(), &stringArrayData); + StringArray stringArray = stringArrayData.data; + pvto->shareData(stringArray,from->getCapacity(),from->getLength()); + break; + } + } + to->setImmutable(); + return from->getLength(); +} + +int copyNumericArray(PVScalarArray *from, int offset, PVScalarArray *to, int toOffset, int len) +{ + ScalarType fromElementType = from->getScalarArray()->getElementType(); + int ncopy = 0; + switch (fromElementType) { + case pvBoolean: + throw std::logic_error(String("PVBooleanArray is not a numeric array")); + case pvByte: { + PVByteArray *pvfrom = (PVByteArray*) from; + while (len > 0) { + int num = 0; + ByteArrayData byteArrayData = ByteArrayData(); + num = pvfrom->get(offset, len, &byteArrayData); + ByteArray data = byteArrayData.data; + int dataOffset = byteArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromByteArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvShort: { + PVShortArray *pvfrom = (PVShortArray*) from; + while (len > 0) { + int num = 0; + ShortArrayData shortArrayData = ShortArrayData(); + num = pvfrom->get(offset, len, &shortArrayData); + ShortArray data = shortArrayData.data; + int dataOffset = shortArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromShortArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvInt: { + PVIntArray *pvfrom = (PVIntArray*) from; + while (len > 0) { + int num = 0; + IntArrayData shortArrayData = IntArrayData(); + num = pvfrom->get(offset, len, &shortArrayData); + IntArray data = shortArrayData.data; + int dataOffset = shortArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromIntArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvLong: { + PVLongArray *pvfrom = (PVLongArray*) from; + while (len > 0) { + int num = 0; + LongArrayData longArrayData = LongArrayData(); + num = pvfrom->get(offset, len, &longArrayData); + LongArray data = longArrayData.data; + int dataOffset = longArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromLongArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvFloat: { + PVFloatArray *pvfrom = (PVFloatArray*) from; + while (len > 0) { + int num = 0; + FloatArrayData floatArrayData = FloatArrayData(); + num = pvfrom->get(offset, len, &floatArrayData); + FloatArray data = floatArrayData.data; + int dataOffset = floatArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromFloatArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvDouble: { + PVDoubleArray *pvfrom = (PVDoubleArray*) from; + while (len > 0) { + int num = 0; + DoubleArrayData doubleArrayData = DoubleArrayData(); + num = pvfrom->get(offset, len, &doubleArrayData); + DoubleArray data = doubleArrayData.data; + int dataOffset = doubleArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromDoubleArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvString: + throw std::logic_error(String("PVStringArray is not a numeric array")); + } + return ncopy; +} + +class ConvertExt : public Convert { +public: + ConvertExt(): Convert(){}; +}; + +Convert * getConvert() { + static Mutex mutex = Mutex(); + Lock xx(&mutex); + + if(convert==0){ + convert = new ConvertExt(); + pvDataCreate = getPVDataCreate(); + } + return convert; +} + +}} diff --git a/pvDataApp/factory/3139 b/pvDataApp/factory/3139 new file mode 100644 index 0000000..ea6403c --- /dev/null +++ b/pvDataApp/factory/3139 @@ -0,0 +1,3578 @@ +/* Convert.cpp */ +#include +#include +#include +#include +#include "lock.h" +#include "pvIntrospect.h" +#include "pvData.h" +#include "convert.h" + +namespace epics { namespace pvData { + +static Convert* convert = 0; +static PVDataCreate* pvDataCreate = 0; + +static String trueString("true"); +static String falseString("false"); +static String logicError("Logic error. Should never get here."); +static String illegalScalarType("Illegal ScalarType"); + +static bool convertEquals(PVField *a,PVField *b); +static int convertFromByteArray(PVScalarArray *pv, int offset, + int len,int8 from[], int fromOffset); +static int convertToByteArray(PVScalarArray *pv, int offset, + int len,int8 to[], int toOffset); +static int convertFromShortArray(PVScalarArray *pv, int offset, + int len,int16 from[], int fromOffset); +static int convertToShortArray(PVScalarArray *pv, int offset, + int len,int16 to[], int toOffset); +static int convertFromIntArray(PVScalarArray *pv, int offset, + int len,int32 from[], int fromOffset); +static int convertToIntArray(PVScalarArray *pv, int offset, + int len,int32 to[], int toOffset); +static int convertFromLongArray(PVScalarArray *pv, int offset, + int len,int64 from[], int fromOffset); +static int convertToLongArray(PVScalarArray * pv, int offset, + int len,int64 to[], int toOffset); +static int convertFromFloatArray(PVScalarArray *pv, int offset, + int len,float from[], int fromOffset); +static int convertToFloatArray(PVScalarArray * pv, int offset, + int len,float to[], int toOffset); +static int convertFromDoubleArray(PVScalarArray *pv, int offset, + int len,double from[], int fromOffset); +static int convertToDoubleArray(PVScalarArray * pv, int offset, + int len,double to[], int toOffset); +static int convertFromStringArray(PVScalarArray *pv, int offset, + int len,String from[], int fromOffset); +static int convertToStringArray(PVScalarArray * pv, int offset, + int len,String to[], int toOffset); + +static void convertToString(StringBuilder buffer, + PVField * pv,int indentLevel); +static void convertStructure(StringBuilder buffer, + PVStructure *data,int indentLevel); +static void convertArray(StringBuilder buffer, + PVScalarArray * pv,int indentLevel); +static void convertStructureArray(StringBuilder buffer, + PVStructureArray * pvdata,int indentLevel); +static int copyArrayDataReference(PVScalarArray *from,PVArray *to); +static int copyNumericArray(PVScalarArray *from, + int offset, PVScalarArray *to, int toOffset, int len); + +static std::vector split(String commaSeparatedList); + +static std::vector split(String commaSeparatedList) { + String::size_type numValues = 1; + String::size_type index=0; + while(true) { + String::size_type pos = commaSeparatedList.find(',',index); + if(pos==String::npos) break; + numValues++; + index = pos +1; + } + std::vector valueList(numValues,""); + index=0; + for(size_t i=0; iempty(); + *buf += pvField->getField()->getFieldName(); + PVStructure *parent; + while((parent=pvField->getParent())!=0) { + pvField = pvField->getParent(); + String name = pvField->getField()->getFieldName(); + if(name.length()>0) { + buf->insert(0,"."); + buf->insert(0,name); + } + } +} + +bool Convert::equals(PVField *a,PVField *b) +{ + return convertEquals(a,b); +} + +void Convert::getString(StringBuilder buf,PVField * pvField,int indentLevel) +{ + convertToString(buf,pvField,indentLevel); +} + +void Convert::getString(StringBuilder buf,PVField * pvField) +{ + convertToString(buf,pvField,0); +} + +void Convert::fromString(PVScalar *pvScalar, String from) +{ + ScalarConstPtr scalar = pvScalar->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: { + PVBoolean *pv = (PVBoolean *)pvScalar; + bool value = + ((from.compare("true")==0) ? true : false); + pv->put(value); + return; + } + case pvByte : { + PVByte *pv = (PVByte*)pvScalar; + int ival; + sscanf(from.c_str(),"%d",&ival); + int8 value = ival; + pv->put(value); + return; + } + case pvShort : { + PVShort *pv = (PVShort*)pvScalar; + int ival; + sscanf(from.c_str(),"%d",&ival); + int16 value = ival; + pv->put(value); + return; + } + case pvInt : { + PVInt *pv = (PVInt*)pvScalar; + int ival; + sscanf(from.c_str(),"%d",&ival); + int32 value = ival; + pv->put(value); + return; + } + case pvLong : { + PVLong *pv = (PVLong*)pvScalar; + int64 ival; + sscanf(from.c_str(),"%lld",&ival); + int64 value = ival; + pv->put(value); + return; + } + case pvFloat : { + PVFloat *pv = (PVFloat*)pvScalar; + float value; + sscanf(from.c_str(),"%f",&value); + pv->put(value); + return; + } + case pvDouble : { + PVDouble*pv = (PVDouble*)pvScalar; + double value; + sscanf(from.c_str(),"%lf",&value); + pv->put(value); + return; + } + case pvString: { + PVString *value = (PVString*)pvScalar; + value->put(from); + return; + } + } + String message("Convert::fromString unknown scalarType "); + ScalarTypeFunc::toString(&message,scalarType); + throw std::logic_error(message); +} + +int Convert::fromString(PVScalarArray *pv, String from) +{ + if(from[0]=='[' && from[from.length()]==']') { + int offset = from.rfind(']'); + from = from.substr(1, offset); + } + std::vector valueList = split(from); + int length = valueList.size(); + StringArray valueArray = new String[length]; + for(int i=0; isetLength(length); + delete[] valueArray; + return length; +} + +int Convert::fromStringArray(PVScalarArray *pv, int offset, int length, + String from[], int fromOffset) +{ + return convertFromStringArray(pv,offset,length,from,fromOffset); +} + +int Convert::toStringArray(PVScalarArray * pv, int offset, int length, + String to[], int toOffset) +{ + return convertToStringArray(pv,offset,length,to,toOffset); +} + +bool Convert::isCopyCompatible(FieldConstPtr from, FieldConstPtr to) +{ + if(from->getType()!=to->getType()) return false; + switch(from->getType()) { + case scalar: + return isCopyScalarCompatible((ScalarConstPtr)from,(ScalarConstPtr)to); + case scalarArray: + return isCopyScalarArrayCompatible((ScalarArrayConstPtr)from,(ScalarArrayConstPtr)to); + case structure: + return isCopyStructureCompatible((StructureConstPtr)from,(StructureConstPtr)to); + case structureArray: + return isCopyStructureArrayCompatible((StructureArrayConstPtr)from,(StructureArrayConstPtr)to); + } + String message("Convert::isCopyCompatible should never get here"); + throw std::logic_error(message); +} + +void Convert::copy(PVField *from,PVField *to) +{ + switch(from->getField()->getType()) { + case scalar: + copyScalar((PVScalar *)from,(PVScalar *)to); + return; + case scalarArray: { + PVScalarArray *fromArray = (PVScalarArray *)from; + PVScalarArray *toArray = (PVScalarArray *)to; + int length = copyScalarArray(fromArray,0,toArray,0,fromArray->getLength()); + if(toArray->getLength()!=length) toArray->setLength(length); + return; + } + case structure: + copyStructure((PVStructure *)from,(PVStructure *)to); + return; + case structureArray: { + PVStructureArray *fromArray = (PVStructureArray *)from; + PVStructureArray *toArray = (PVStructureArray *)to; + copyStructureArray(fromArray,toArray); + return; + } + } +} + +bool Convert::isCopyScalarCompatible( + ScalarConstPtr fromField, ScalarConstPtr toField) +{ + ScalarType fromScalarType = fromField->getScalarType(); + ScalarType toScalarType = toField->getScalarType(); + if(fromScalarType==toScalarType) return true; + if(ScalarTypeFunc::isNumeric(fromScalarType) + && ScalarTypeFunc::isNumeric(toScalarType)) return true; + if(fromScalarType==pvString) return true; + if(toScalarType==pvString) return true; + return false; +} + +void Convert::copyScalar(PVScalar *from, PVScalar *to) +{ + if(to->isImmutable()) { + if(from==to) return; + String message("Convert.copyScalar destination is immutable"); + throw std::invalid_argument(message); + } + ScalarType fromType = from->getScalar()->getScalarType(); + ScalarType toType = to->getScalar()->getScalarType(); + switch(fromType) { + case pvBoolean: { + if(toType!=pvBoolean) { + if(toType!=pvString) { + String message("Convert.copyScalar arguments are not compatible"); + throw std::invalid_argument(message); + } + } + PVBoolean *data = (PVBoolean*)from; + if(toType==pvString) { + PVString *dataTo = (PVString*)to; + String buf(""); + data->toString(&buf); + dataTo->put(buf); + } else { + bool value = data->get(); + PVBoolean *dataTo = (PVBoolean*)to; + dataTo->put(value); + } + break; + } + case pvByte : { + PVByte *data = (PVByte*)from; + int8 value = data->get(); + convert->fromByte(to,value); + break; + } + case pvShort : { + PVShort *data = (PVShort*)from; + short value = data->get(); + convert->fromShort(to,value); + break; + } + case pvInt :{ + PVInt *data = (PVInt*)from; + int value = data->get(); + convert->fromInt(to,value); + break; + } + case pvLong : { + PVLong *data = (PVLong*)from; + long value = data->get(); + convert->fromLong(to,value); + break; + } + case pvFloat : { + PVFloat *data = (PVFloat*)from; + float value = data->get(); + convert->fromFloat(to,value); + break; + } + case pvDouble : { + PVDouble *data = (PVDouble*)from; + double value = data->get(); + convert->fromDouble(to,value); + break; + } + case pvString: { + PVString *data = (PVString*)from; + String value = data->get(); + convert->fromString(to,value); + break; + } + } + String message("Convert::copyScalar should never get here"); + throw std::logic_error(message); +} + +bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr fromArray, + ScalarArrayConstPtr toArray) +{ + ScalarType fromType = fromArray->getElementType(); + ScalarType toType = toArray->getElementType(); + if(fromType==toType) return true; + if(ScalarTypeFunc::isNumeric(fromType) + && ScalarTypeFunc::isNumeric(toType)) return true; + if(toType==pvString) return true; + if(fromType==pvString) return true; + return false; +} + +int Convert::copyScalarArray(PVScalarArray *from, int offset, + PVScalarArray *to, int toOffset, int length) +{ + if(to->isImmutable()) { + if(from==to) return from->getLength(); + String message("Convert.copyArray destination is immutable"); + throw std::invalid_argument(message); + } + ScalarType fromElementType = from->getScalarArray()->getElementType(); + ScalarType toElementType = to->getScalarArray()->getElementType(); + + if(from->isImmutable() && (fromElementType==toElementType)) { + if(offset==0 && toOffset==0 && length==from->getLength()) { + return copyArrayDataReference(from,to); + } + } + + int ncopy = 0; + if(ScalarTypeFunc::isNumeric(fromElementType) + && ScalarTypeFunc::isNumeric(toElementType)) { + return copyNumericArray(from,offset,to,toOffset,length); + } else if(toElementType==pvBoolean && fromElementType==pvBoolean) { + PVBooleanArray *pvfrom = (PVBooleanArray*)from; + PVBooleanArray *pvto = (PVBooleanArray*)to; + while(length>0) { + int num = 0; + BooleanArray data = 0; + int fromOffset = 0; + BooleanArrayData booleanArrayData = BooleanArrayData(); + num = pvfrom->get(offset,length,&booleanArrayData); + data = booleanArrayData.data; + fromOffset = booleanArrayData.offset; + if(num<=0) return ncopy; + while(num>0) { + int n = pvto->put(toOffset,num,data,fromOffset); + if(n<=0) return ncopy; + length -= n; num -= n; ncopy+=n; offset += n; toOffset += n; + } + } + } else if(toElementType==pvString && fromElementType==pvString) { + PVStringArray *pvfrom = (PVStringArray*)from; + PVStringArray *pvto = (PVStringArray*)to; + while(length>0) { + int num = 0; + String *data; + int fromOffset = 0; + StringArrayData stringArrayData = StringArrayData(); + num = pvfrom->get(offset,length,&stringArrayData); + data = stringArrayData.data; + fromOffset = stringArrayData.offset; + if(num<=0) return ncopy; + while(num>0) { + int n = pvto->put(toOffset,num,data,fromOffset); + if(n<=0) return ncopy; + length -= n; num -= n; ncopy+=n; offset += n; toOffset += n; + } + } + } else if(toElementType==pvString) { + PVStringArray *pvto = (PVStringArray*)to; + ncopy = from->getLength(); + if(ncopy>length) ncopy = length; + int num = ncopy; + String toData[1]; + while(num>0) { + convert->toStringArray(from,offset,1,toData,0); + if(pvto->put(toOffset,1,toData,0)<=0) break; + num--; offset++; toOffset++; + } + return ncopy; + } else if(fromElementType==pvString) { + PVStringArray *pvfrom = (PVStringArray*)from; + while(length>0) { + int num = 0; + String *data = 0; + int fromOffset = 0; + StringArrayData stringArrayData = StringArrayData(); + num = pvfrom->get(offset,length,&stringArrayData); + data = stringArrayData.data; + fromOffset = stringArrayData.offset; + if(num<=0) return ncopy; + while(num>0) { + int n = fromStringArray(to,toOffset,num,data,fromOffset); + if(n<=0) return ncopy; + length -= n; num -= n; ncopy+=n; offset += n; toOffset += n; + } + } + } + String message("Convert::copyScalarArray should not get here"); + throw std::logic_error(message); +} + +bool Convert::isCopyStructureCompatible( + StructureConstPtr fromStruct, StructureConstPtr toStruct) +{ + FieldConstPtrArray fromFields = fromStruct->getFields(); + FieldConstPtrArray toFields = toStruct->getFields(); + int length = fromStruct->getNumberFields(); + if(length!=toStruct->getNumberFields()) return false; + for(int i=0; igetType(); + Type toType = to->getType(); + if(fromType!=toType) return false; + switch(fromType) { + case scalar: + if(!convert->isCopyScalarCompatible((ScalarConstPtr)from,(ScalarConstPtr)to)) return false; + break; + case scalarArray: + if(!isCopyScalarArrayCompatible((ScalarArrayConstPtr)from,(ScalarArrayConstPtr)to)) + return false; + break; + case structure: + if(!isCopyStructureCompatible((StructureConstPtr)from,(StructureConstPtr)to)) + return false; + break; + case structureArray: + if(!isCopyStructureArrayCompatible((StructureArrayConstPtr)from, + (StructureArrayConstPtr)to)) return false; + } + } + return true; +} + +void Convert::copyStructure(PVStructure *from, PVStructure *to) +{ + if(to->isImmutable()) { + if(from==to) return; + String message("Convert.copyStructure destination is immutable"); + throw std::invalid_argument(message); + } + if(from==to) return; + PVFieldPtrArray fromDatas = from->getPVFields(); + PVFieldPtrArray toDatas = to->getPVFields(); + if(from->getStructure()->getNumberFields() + != to->getStructure()->getNumberFields()) { + String message("Convert.copyStructure Illegal copyStructure"); + throw std::invalid_argument(message); + } + int numberFields = from->getStructure()->getNumberFields(); + if(numberFields==2) { + // look for enumerated structure and copy choices first + String fieldName = fromDatas[0]->getField()->getFieldName(); + if(fieldName.compare("index")==0) { + FieldConstPtr fieldIndex = fromDatas[0]->getField(); + FieldConstPtr fieldChoices = fromDatas[1]->getField(); + if(fieldIndex->getType()==scalar + && fieldChoices->getFieldName().compare("choices") + && fieldChoices->getType()==scalarArray) { + PVScalar *pvScalar = (PVScalar*)fromDatas[0]; + PVScalarArray *pvArray = (PVScalarArray*)fromDatas[1]; + if((pvScalar->getScalar()->getScalarType()==pvInt) + && (pvArray->getScalarArray()->getElementType()==pvString)) { + PVScalarArray* toArray = (PVScalarArray*)toDatas[1]; + copyScalarArray(pvArray,0,toArray,0,pvArray->getLength()); + PVScalar *toScalar = (PVScalar*)toDatas[0]; + copyScalar(pvScalar,toScalar); + return; + } + } + } + } + for(int i=0; i < numberFields; i++) { + PVField *fromData = fromDatas[i]; + PVField *toData = toDatas[i]; + Type fromType = fromData->getField()->getType(); + Type toType = toData->getField()->getType(); + if(fromType!=toType) { + String message("Convert.copyStructure Illegal copyStructure"); + throw std::invalid_argument(message); + } + switch(fromType) { + case scalar: + copyScalar((PVScalar*)fromData,(PVScalar*)toData); + break; + case scalarArray: { + PVScalarArray *fromArray = (PVScalarArray*)fromData; + PVScalarArray *toArray = (PVScalarArray*)toData; + int length = copyScalarArray(fromArray,0,toArray,0,fromArray->getLength()); + if(toArray->getLength()!=length) toArray->setLength(length); + break; + } + case structure: + copyStructure((PVStructure*)fromData,(PVStructure*)toData); + break; + case structureArray: { + PVStructureArray *fromArray = (PVStructureArray*)fromData; + PVStructureArray *toArray = (PVStructureArray*)toData; + copyStructureArray(fromArray,toArray); + break; + } + } + } +} + +bool Convert::isCopyStructureArrayCompatible( + StructureArrayConstPtr from, StructureArrayConstPtr to) +{ + return isCopyStructureCompatible(from->getStructure(),to->getStructure()); +} + +void Convert::copyStructureArray( + PVStructureArray *from, PVStructureArray *to) +{ + if(to->isImmutable()) { + if(from==to) return; + String message("Convert.copyStructureArray destination is immutable"); + throw std::invalid_argument(message); + } + if(!isCopyStructureCompatible( + from->getStructureArray()->getStructure(), + to->getStructureArray()->getStructure())) { + String message("Convert.copyStructureArray from and to are not compatible"); + throw std::invalid_argument(message); + } + PVStructurePtrArray fromArray = 0; + int length = from->getLength(); + StructureArrayData structureArrayData = StructureArrayData(); + from->get(0, length,&structureArrayData); + fromArray = structureArrayData.data; + PVStructurePtrArray toArray = 0; + if(to->getCapacity()setCapacity(length); + to->get(0, length,&structureArrayData); + toArray = structureArrayData.data; + for(int i=0; igetStructureArray()->getStructure(); + toArray[i] = pvDataCreate->createPVStructure(0,structure); + } + copyStructure(fromArray[i],toArray[i]); + } + } + to->setLength(length); + to->postPut(); +} + +int8 Convert::toByte(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to byte")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to byte")); + } + throw std::logic_error(logicError); +} + +int16 Convert::toShort(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to short")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to short")); + } + throw std::logic_error(logicError); +} + +int32 Convert::toInt(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to int")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to int")); + } + throw std::logic_error(logicError); +} + +int64 Convert::toLong(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to long")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to long")); + } + throw std::logic_error(logicError); +} + +float Convert::toFloat(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to float")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to float")); + } + throw std::logic_error(logicError); +} + +double Convert::toDouble(PVScalar * pv) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("boolean can not be converted to double")); + case pvByte: { + PVByte *value = (PVByte *)pv; + return value->get(); + } + case pvShort: { + PVShort *value = (PVShort *)pv; + return value->get(); + } + case pvInt: { + PVInt *value = (PVInt *)pv; + return value->get(); + } + case pvLong: { + PVLong *value = (PVLong *)pv; + return value->get(); + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + return value->get(); + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + return value->get(); + } + case pvString: + throw std::logic_error(String("string can not be converted to double")); + } + throw std::logic_error(logicError); +} + +void Convert::fromByte(PVScalar *pv,int8 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("byte can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int ival = from; + sprintf(buffer,"%d",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromShort(PVScalar *pv,int16 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("short can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int ival = from; + sprintf(buffer,"%d",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromInt(PVScalar *pv, int32 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("int can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int ival = from; + sprintf(buffer,"%d",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromLong(PVScalar *pv, int64 from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("long can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + int64 ival = from; + sprintf(buffer,"%lld",ival); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromFloat(PVScalar* pv, float from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("float can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + double dval = from; + sprintf(buffer,"%g",dval); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +void Convert::fromDouble(PVScalar *pv, double from) +{ + ScalarConstPtr scalar = pv->getScalar(); + ScalarType scalarType = scalar->getScalarType(); + switch(scalarType) { + case pvBoolean: + throw std::logic_error(String("double can not be converted to boolean")); + case pvByte: { + PVByte *value = (PVByte *)pv; + value->put(from); return; + } + case pvShort: { + PVShort *value = (PVShort *)pv; + value->put(from); return; + } + case pvInt: { + PVInt *value = (PVInt *)pv; + value->put(from); return; + } + case pvLong: { + PVLong *value = (PVLong *)pv; + value->put(from); return; + } + case pvFloat: { + PVFloat *value = (PVFloat *)pv; + value->put(from); return; + } + case pvDouble: { + PVDouble *value = (PVDouble *)pv; + value->put(from); return; + } + case pvString: { + PVString *value = (PVString *)pv; + char buffer[20]; + double dval = from; + sprintf(buffer,"%g",dval); + String xxx(buffer); + value->put(xxx); + return; + } + } + throw std::logic_error(logicError); +} + +int Convert::toByteArray(PVScalarArray * pv, int offset, int length, + int8 to[], int toOffset) +{ + return convertToByteArray(pv, offset, length, to, toOffset); +} + +int Convert::toShortArray(PVScalarArray * pv, int offset, int length, + int16 to[], int toOffset) +{ + return convertToShortArray(pv, offset, length, to, toOffset); +} + +int Convert::toIntArray(PVScalarArray * pv, int offset, int length, + int32 to[], int toOffset) +{ + return convertToIntArray(pv, offset, length, to, toOffset); +} + +int Convert::toLongArray(PVScalarArray * pv, int offset, int length, + int64 to[], int toOffset) +{ + return convertToLongArray(pv, offset, length, to, toOffset); +} + +int Convert::toFloatArray(PVScalarArray * pv, int offset, int length, + float to[], int toOffset) +{ + return convertToFloatArray(pv, offset, length, to, toOffset); +} + +int Convert::toDoubleArray(PVScalarArray * pv, int offset, int length, + double to[], int toOffset) +{ + return convertToDoubleArray(pv, offset, length, to, toOffset); +} + +int Convert::fromByteArray(PVScalarArray *pv, int offset, int length, + int8 from[], int fromOffset) +{ + return convertFromByteArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromShortArray(PVScalarArray *pv, int offset, int length, + int16 from[], int fromOffset) +{ + return convertFromShortArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromIntArray(PVScalarArray *pv, int offset, int length, + int32 from[], int fromOffset) +{ + return convertFromIntArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromLongArray(PVScalarArray *pv, int offset, int length, + int64 from[], int fromOffset) +{ + return convertFromLongArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromFloatArray(PVScalarArray *pv, int offset, int length, + float from[], int fromOffset) +{ + return convertFromFloatArray(pv, offset, length, from, fromOffset); +} + +int Convert::fromDoubleArray(PVScalarArray *pv, int offset, int length, + double from[], int fromOffset) +{ + return convertFromDoubleArray(pv, offset, length, from, fromOffset); +} + +void Convert::newLine(StringBuilder buffer, int indentLevel) +{ + *buffer += "\n"; + for(int i=0; igetScalar()->getScalarType(); + ScalarType bscalarType = b->getScalar()->getScalarType(); + if(ascalarType!=bscalarType) return false; + switch(ascalarType) { + case pvBoolean: { + PVBoolean *pa = (PVBoolean *)a; + PVBoolean *pb = (PVBoolean *)b; + bool avalue = pa->get(); + bool bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvByte: { + PVByte *pa = (PVByte *)a; + PVByte *pb = (PVByte *)b; + int8 avalue = pa->get(); + int8 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvShort: { + PVShort *pa = (PVShort *)a; + PVShort *pb = (PVShort *)b; + int16 avalue = pa->get(); + int16 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvInt: { + PVInt *pa = (PVInt *)a; + PVInt *pb = (PVInt *)b; + int32 avalue = pa->get(); + int32 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvLong: { + PVLong *pa = (PVLong *)a; + PVLong *pb = (PVLong *)b; + int64 avalue = pa->get(); + int64 bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvFloat: { + PVFloat *pa = (PVFloat *)a; + PVFloat *pb = (PVFloat *)b; + float avalue = pa->get(); + float bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvDouble: { + PVDouble *pa = (PVDouble *)a; + PVDouble *pb = (PVDouble *)b; + double avalue = pa->get(); + double bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + case pvString: { + PVString *pa = (PVString *)a; + PVString *pb = (PVString *)b; + String avalue = pa->get(); + String bvalue = pb->get(); + return ((avalue==bvalue) ? true : false); + } + } + String message("should not get here"); + throw std::logic_error(message); +} + +static bool arrayEquals(PVScalarArray *a,PVScalarArray *b) +{ + if(a==b) return true; + ScalarType aType = a->getScalarArray()->getElementType(); + ScalarType bType = b->getScalarArray()->getElementType(); + if(aType!=bType) return false; + if(a->getLength()!=b->getLength()) return false; + int length = a->getLength(); + switch(aType) { + case pvBoolean: { + PVBooleanArray *aarray = (PVBooleanArray *)a; + PVBooleanArray *barray = (PVBooleanArray *)b; + BooleanArrayData adata = BooleanArrayData(); + BooleanArrayData bdata = BooleanArrayData(); + aarray->get(0,length,&adata); + barray->get(0,length,&bdata); + BooleanArray avalue = adata.data; + BooleanArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + ByteArray avalue = adata.data; + ByteArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + ShortArray avalue = adata.data; + ShortArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + IntArray avalue = adata.data; + IntArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + LongArray avalue = adata.data; + LongArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + FloatArray avalue = adata.data; + FloatArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + DoubleArray avalue = adata.data; + DoubleArray bvalue = bdata.data; + for(int i=0; iget(0,length,&adata); + barray->get(0,length,&bdata); + String *avalue = adata.data; + String *bvalue = bdata.data; + for(int i=0; igetStructureArray()->getStructure(); + StructureConstPtr bStructure = b->getStructureArray()->getStructure(); + if(aStructure!=bStructure) return false; + if(a->getLength()!=b->getLength()) return false; + StructureArrayData aData = StructureArrayData(); + StructureArrayData bData = StructureArrayData(); + int length = a->getLength(); + PVStructurePtrArray aArray = aData.data; + PVStructurePtrArray bArray = bData.data; + if(aArray==bArray) return true; + for(int i=0; igetStructure(); + StructureConstPtr bStructure = a->getStructure(); + int length = aStructure->getNumberFields(); + if(length!=bStructure->getNumberFields()) return false; + PVFieldPtrArray aFields = a->getPVFields(); + PVFieldPtrArray bFields = b->getPVFields(); + for(int i=0; igetField()->getType(); + Type btype = b->getField()->getType(); + if(atype!=btype) return false; + if(atype==scalar) return scalarEquals((PVScalar *)a,(PVScalar *)b); + if(atype==scalarArray) { + return arrayEquals((PVScalarArray *)a,(PVScalarArray *)b); + } + if(atype==structureArray) { + return structureArrayEquals( + (PVStructureArray *)a,(PVStructureArray *)b); + } + if(atype==structure) { + return structureEquals((PVStructure *)a,(PVStructure *)b); + } + String message("should not get here"); + throw std::logic_error(message); +} + +int convertFromByteArray(PVScalarArray *pv, int offset, int len,int8 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from byte[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from byte[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromByteArray should never get here"); + throw std::logic_error(message); +} + +int convertToByteArray(PVScalarArray * pv, int offset, int len,int8 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to byte[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to byte[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToByteArray should never get here"); + throw std::logic_error(message); +} + +int convertFromShortArray(PVScalarArray *pv, int offset, int len,int16 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from short[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from short[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromShortArray should never get here"); + throw std::logic_error(message); +} + +int convertToShortArray(PVScalarArray * pv, int offset, int len,int16 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to short[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to short[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToShortArray should never get here"); + throw std::logic_error(message); +} + +int convertFromIntArray(PVScalarArray *pv, int offset, int len,int32 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from int[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from int[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromIntArray should never get here"); + throw std::logic_error(message); +} + +int convertToIntArray(PVScalarArray * pv, int offset, int len,int32 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to byte[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to int[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToIntArray should never get here"); + throw std::logic_error(message); +} + +int convertFromLongArray(PVScalarArray *pv, int offset, int len,int64 from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from long[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from long[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromLongArray should never get here"); + throw std::logic_error(message); +} + +int convertToLongArray(PVScalarArray * pv, int offset, int len,int64 to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to long[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to long[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToLongArray should never get here"); + throw std::logic_error(message); +} + +int convertFromFloatArray(PVScalarArray *pv, int offset, int len,float from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from float[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + data[0] = (double) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: { + String message("convert from float[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromFloatArray should never get here"); + throw std::logic_error(message); +} + +int convertToFloatArray(PVScalarArray * pv, int offset, int len,float to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to float[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to float[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToFloatArray should never get here"); + throw std::logic_error(message); +} + +int convertFromDoubleArray(PVScalarArray *pv, int offset, int len,double from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert from double[] to BooleanArray not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + data[0] = (int8) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + data[0] = (int16) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + data[0] = (int32) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + data[0] = (int64) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + data[0] = (float) from[fromOffset]; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + case pvString: { + String message("convert from double[] to StringArray not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertFromDoubleArray should never get here"); + throw std::logic_error(message); +} + +int convertToDoubleArray(PVScalarArray * pv, int offset, int len,double to[], int toOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + String message("convert BooleanArray to float[]] not legal"); + throw std::invalid_argument(message); + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + while (len > 0) { + int num = 0; + num = pvdata->get(offset,len,&data); + if (num <= 0) break; + ByteArray dataArray = data.data; + int dataOffset = data.offset; + for(int i=0;i 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + ShortArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + IntArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + LongArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) break; + FloatArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + while (len > 0) { + int num = pvdata->get(offset, len, &data); + if (num == 0) + break; + DoubleArray dataArray = data.data; + int dataOffset = data.offset; + for (int i = 0; i < num; i++) + to[i + toOffset] = (int8) dataArray[i + dataOffset]; + len -= num; + offset += num; + toOffset += num; + ntransfered += num; + } + return ntransfered; + } + case pvString: { + String message("convert StringArray to double[]] not legal"); + throw std::invalid_argument(message); + } + } + String message("Convert::convertToDoubleArray should never get here"); + throw std::logic_error(message); +} + +int convertFromStringArray(PVScalarArray *pv, int offset, int len,String from[], int fromOffset) +{ + ScalarType elemType = pv->getScalarArray()->getElementType(); + int ntransfered = 0; + switch (elemType) { + case pvBoolean: { + PVBooleanArray *pvdata = (PVBooleanArray*) pv; + bool data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + data[0] = (fromString.compare("true")==0) ? true : false; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + int8 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int ival; + sscanf(fromString.c_str(),"%d",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + int16 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int ival; + sscanf(fromString.c_str(),"%d",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + int32 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int ival; + sscanf(fromString.c_str(),"%d",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + int64 data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + int64 ival; + sscanf(fromString.c_str(),"%lld",&ival); + data[0] = ival; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + float data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + float fval; + sscanf(fromString.c_str(),"%f",&fval); + data[0] = fval; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + double data[1]; + while (len > 0) { + String fromString = from[fromOffset]; + double fval; + sscanf(fromString.c_str(),"%lf",&fval); + data[0] = fval; + if (pvdata->put(offset, 1, data, 0) == 0) + return ntransfered; + --len; + ++ntransfered; + ++offset; + ++fromOffset; + } + return ntransfered; + } + case pvString: + PVStringArray *pvdata = (PVStringArray*) pv; + while (len > 0) { + int n = pvdata->put(offset, len, from, fromOffset); + if (n == 0) + break; + len -= n; + offset += n; + fromOffset += n; + ntransfered += n; + } + return ntransfered; + } + String message("Convert::convertFromStringArray should never get here"); + throw std::logic_error(message); +} + +int convertToStringArray(PVScalarArray * pv, int offset, int len,String to[], int toOffset) +{ + ScalarType elementType = pv->getScalarArray()->getElementType(); + int ncopy = pv->getLength(); + if (ncopy > len) ncopy = len; + int num = ncopy; + switch (elementType) { + case pvBoolean: { + PVBooleanArray *pvdata = (PVBooleanArray*) pv; + BooleanArrayData data = BooleanArrayData(); + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + BooleanArray dataArray = data.data; + bool value = dataArray[data.offset]; + to[toOffset + i] = value ? trueString : falseString; + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvByte: { + PVByteArray *pvdata = (PVByteArray*) pv; + ByteArrayData data = ByteArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + ByteArray dataArray = data.data; + int ival = dataArray[data.offset]; + sprintf(cr,"%d",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvShort: { + PVShortArray *pvdata = (PVShortArray*) pv; + ShortArrayData data = ShortArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + ShortArray dataArray = data.data; + int ival = dataArray[data.offset]; + sprintf(cr,"%d",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvInt: { + PVIntArray *pvdata = (PVIntArray*) pv; + IntArrayData data = IntArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + IntArray dataArray = data.data; + int ival = dataArray[data.offset]; + sprintf(cr,"%d",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvLong: { + PVLongArray *pvdata = (PVLongArray*) pv; + LongArrayData data = LongArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + LongArray dataArray = data.data; + int64 ival = dataArray[data.offset]; + sprintf(cr,"%lld",ival); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*) pv; + FloatArrayData data = FloatArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + FloatArray dataArray = data.data; + float fval = dataArray[data.offset]; + sprintf(cr,"%g",fval); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*) pv; + DoubleArrayData data = DoubleArrayData(); + char cr[30]; + for (int i = 0; i < num; i++) { + if (pvdata->get(offset + i, 1, &data) == 1) { + DoubleArray dataArray = data.data; + double fval = dataArray[data.offset]; + sprintf(cr,"%g",fval); + to[toOffset + i] = String(cr); + } else { + to[toOffset + i] = "bad pv"; + } + } + } + break; + case pvString: { + PVStringArray *pvdata = (PVStringArray*) pv; + while (num > 0) { + int numnow = 0; + StringArray dataArray = 0; + int dataOffset = 0; + StringArrayData stringArrayData = StringArrayData(); + numnow = pvdata->get(offset, num, &stringArrayData); + dataArray = stringArrayData.data; + dataOffset = stringArrayData.offset; + if (numnow <= 0) { + for (int i = 0; i < num; i++) + to[toOffset + i] = "bad pv"; + break; + } + for(int i=0; igetField()->getType(); + if(type==scalarArray) { + return convertArray(buffer,(PVScalarArray *)pv,indentLevel); + } + if(type==structure) { + return convertStructure(buffer,(PVStructure*)pv,indentLevel); + } + if(type==structureArray) { + return convertStructureArray(buffer,(PVStructureArray*)pv,indentLevel); + } + PVScalar *pvScalar = (PVScalar*)pv; + ScalarConstPtr pscalar = pvScalar->getScalar(); + ScalarType scalarType = pscalar->getScalarType(); + ScalarTypeFunc::toString(buffer,scalarType); + *buffer += " "; + *buffer += pscalar->getFieldName(); + *buffer += " "; + switch(scalarType) { + case pvBoolean: { + PVBoolean *data = (PVBoolean*)pv; + bool value = data->get(); + if(value) { + *buffer += "true"; + } else { + *buffer += "false"; + } + } + return; + case pvByte: { + PVByte *data = (PVByte*)pv; + char xxx[30]; + sprintf(xxx,"%d",(int)data->get()); + *buffer += xxx; + } + return; + case pvShort: { + PVShort *data = (PVShort*)pv; + char xxx[30]; + sprintf(xxx,"%d",(int)data->get()); + *buffer += xxx; + } + return; + case pvInt: { + PVInt *data = (PVInt*)pv; + char xxx[30]; + sprintf(xxx,"%d",(int)data->get()); + *buffer += xxx; + } + return; + case pvLong: { + PVLong *data = (PVLong*)pv; + char xxx[30]; + sprintf(xxx,"%lld",(int64)data->get()); + *buffer += xxx; + } + return; + case pvFloat: { + PVFloat *data = (PVFloat*)pv; + char xxx[30]; + sprintf(xxx,"%g",data->get()); + *buffer += xxx; + } + return; + case pvDouble: { + PVDouble *data = (PVDouble*)pv; + char xxx[30]; + sprintf(xxx,"%lg",data->get()); + *buffer += xxx; + } + return; + case pvString: { + PVString *data = (PVString*)pv; + *buffer += data->get(); + } + return; + default: + *buffer += "unknown ScalarType"; + } +} + +void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel) +{ + *buffer += "structure "; + *buffer += data->getField()->getFieldName(); + convert->newLine(buffer, indentLevel+1); + PVFieldPtrArray fieldsData = data->getPVFields(); + if (fieldsData != 0) { + int length = data->getStructure()->getNumberFields(); + for(int i=0; itoString(buffer,indentLevel + 1); + if(inewLine(buffer, indentLevel+1); + } + } +} + +void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel) +{ + ScalarArrayConstPtr array = pv->getScalarArray(); + ScalarType type = array->getElementType(); + switch(type) { + case pvBoolean: { + PVBooleanArray *pvdata = (PVBooleanArray*)pv; + BooleanArrayData data = BooleanArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ","; + int num = pvdata->get(i,1,&data); + if(num==1) { + BooleanArray value = data.data; + if(value[data.offset]) { + *buffer += "true"; + } else { + *buffer += "false"; + } + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvByte: { + PVByteArray *pvdata = (PVByteArray*)pv; + ByteArrayData data = ByteArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ","; + int num = pvdata->get(i,1,&data); + if(num==1) { + int val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%d",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvShort: { + PVShortArray *pvdata = (PVShortArray*)pv; + ShortArrayData data = ShortArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + int val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%d",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvInt: { + PVIntArray *pvdata = (PVIntArray*)pv; + IntArrayData data = IntArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + int val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%d",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvLong: { + PVLongArray *pvdata = (PVLongArray*)pv; + LongArrayData data = LongArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + int64 val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%lld",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvFloat: { + PVFloatArray *pvdata = (PVFloatArray*)pv; + FloatArrayData data = FloatArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + float val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%g",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += "]"; + break; + } + case pvDouble: { + PVDoubleArray *pvdata = (PVDoubleArray*)pv; + DoubleArrayData data = DoubleArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ','; + int num = pvdata->get(i,1,&data); + if(num==1) { + double val = data.data[data.offset]; + char buf[16]; + sprintf(buf,"%lg",val); + *buffer += buf; + } else { + *buffer += "???? "; + } + } + *buffer += ("]"); + break; + } + case pvString: { + PVStringArray *pvdata = (PVStringArray*)pv; + StringArrayData data = StringArrayData(); + *buffer += "["; + for(int i=0; i < pvdata->getLength(); i++) { + if(i!=0) *buffer += ","; + int num = pvdata->get(i,1,&data); + StringPtrArray value = data.data; + if(num==1) { + if(value[data.offset].length()>0) { + *buffer += value[data.offset].c_str(); + } else { + *buffer += "null"; + } + } else { + *buffer += "null"; + } + } + *buffer += "]"; + break; + } + default: + *buffer += " array element is unknown ScalarType"; + } + if(pv->isImmutable()) { + *buffer += " immutable "; + } +} + +void convertStructureArray(StringBuilder buffer, + PVStructureArray * pvdata,int indentLevel) +{ + StructureArrayData data = StructureArrayData(); + int length = pvdata->getLength(); + pvdata->get(0, length, &data); + *buffer += "["; + for (int i = 0; i < length; i++) { + if (i != 0) { + *buffer += ","; + } + convert->newLine(buffer, indentLevel + 1); + PVStructure *pvStructure = data.data[i]; + if (pvStructure == 0) { + *buffer += "null"; + } else { + pvStructure->toString(buffer,indentLevel+1); + } + } + convert->newLine(buffer, indentLevel); + *buffer += "]"; +} + +int copyArrayDataReference(PVScalarArray *from,PVArray *to) +{ + ScalarType scalarType = from->getScalarArray()->getElementType(); + switch (scalarType) { + case pvBoolean: { + PVBooleanArray *pvfrom = (PVBooleanArray*) from; + PVBooleanArray *pvto = (PVBooleanArray*) to; + BooleanArrayData booleanArrayData = BooleanArrayData(); + pvfrom->get(0, pvfrom->getLength(), &booleanArrayData); + BooleanArray booleanArray = booleanArrayData.data; + pvto->shareData(booleanArray,from->getCapacity(),from->getLength()); + break; + } + case pvByte: { + PVByteArray *pvfrom = (PVByteArray*) from; + PVByteArray *pvto = (PVByteArray*) to; + ByteArrayData byteArrayData = ByteArrayData(); + pvfrom->get(0, pvfrom->getLength(), &byteArrayData); + ByteArray byteArray = byteArrayData.data; + pvto->shareData(byteArray,from->getCapacity(),from->getLength()); + break; + } + case pvShort: { + PVShortArray *pvfrom = (PVShortArray*) from; + PVShortArray *pvto = (PVShortArray*) to; + ShortArrayData shortArrayData = ShortArrayData(); + pvfrom->get(0, pvfrom->getLength(), &shortArrayData); + ShortArray shortArray = shortArrayData.data; + pvto->shareData(shortArray,from->getCapacity(),from->getLength()); + break; + } + case pvInt: { + PVIntArray *pvfrom = (PVIntArray*) from; + PVIntArray *pvto = (PVIntArray*) to; + IntArrayData intArrayData = IntArrayData(); + pvfrom->get(0, pvfrom->getLength(), &intArrayData); + IntArray intArray = intArrayData.data; + pvto->shareData(intArray,from->getCapacity(),from->getLength()); + break; + } + case pvLong: { + PVLongArray *pvfrom = (PVLongArray*) from; + PVLongArray *pvto = (PVLongArray*) to; + LongArrayData longArrayData = LongArrayData(); + pvfrom->get(0, pvfrom->getLength(), &longArrayData); + LongArray longArray = longArrayData.data; + pvto->shareData(longArray,from->getCapacity(),from->getLength()); + break; + } + case pvFloat: { + PVFloatArray *pvfrom = (PVFloatArray*) from; + PVFloatArray *pvto = (PVFloatArray*) to; + FloatArrayData longArrayData = FloatArrayData(); + pvfrom->get(0, pvfrom->getLength(), &longArrayData); + FloatArray longArray = longArrayData.data; + pvto->shareData(longArray,from->getCapacity(),from->getLength()); + break; + } + case pvDouble: { + PVDoubleArray *pvfrom = (PVDoubleArray*) from; + PVDoubleArray *pvto = (PVDoubleArray*) to; + DoubleArrayData doubleArrayData = DoubleArrayData(); + pvfrom->get(0, pvfrom->getLength(), &doubleArrayData); + DoubleArray doubleArray = doubleArrayData.data; + pvto->shareData(doubleArray,from->getCapacity(),from->getLength()); + break; + } + case pvString: { + PVStringArray *pvfrom = (PVStringArray*) from; + PVStringArray *pvto = (PVStringArray*) to; + StringArrayData stringArrayData = StringArrayData(); + pvfrom->get(0, pvfrom->getLength(), &stringArrayData); + StringArray stringArray = stringArrayData.data; + pvto->shareData(stringArray,from->getCapacity(),from->getLength()); + break; + } + } + to->setImmutable(); + return from->getLength(); +} + +int copyNumericArray(PVScalarArray *from, int offset, PVScalarArray *to, int toOffset, int len) +{ + ScalarType fromElementType = from->getScalarArray()->getElementType(); + int ncopy = 0; + switch (fromElementType) { + case pvBoolean: + throw std::logic_error(String("PVBooleanArray is not a numeric array")); + case pvByte: { + PVByteArray *pvfrom = (PVByteArray*) from; + while (len > 0) { + int num = 0; + ByteArrayData byteArrayData = ByteArrayData(); + num = pvfrom->get(offset, len, &byteArrayData); + ByteArray data = byteArrayData.data; + int dataOffset = byteArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromByteArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvShort: { + PVShortArray *pvfrom = (PVShortArray*) from; + while (len > 0) { + int num = 0; + ShortArrayData shortArrayData = ShortArrayData(); + num = pvfrom->get(offset, len, &shortArrayData); + ShortArray data = shortArrayData.data; + int dataOffset = shortArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromShortArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvInt: { + PVIntArray *pvfrom = (PVIntArray*) from; + while (len > 0) { + int num = 0; + IntArrayData shortArrayData = IntArrayData(); + num = pvfrom->get(offset, len, &shortArrayData); + IntArray data = shortArrayData.data; + int dataOffset = shortArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromIntArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvLong: { + PVLongArray *pvfrom = (PVLongArray*) from; + while (len > 0) { + int num = 0; + LongArrayData longArrayData = LongArrayData(); + num = pvfrom->get(offset, len, &longArrayData); + LongArray data = longArrayData.data; + int dataOffset = longArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromLongArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvFloat: { + PVFloatArray *pvfrom = (PVFloatArray*) from; + while (len > 0) { + int num = 0; + FloatArrayData floatArrayData = FloatArrayData(); + num = pvfrom->get(offset, len, &floatArrayData); + FloatArray data = floatArrayData.data; + int dataOffset = floatArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromFloatArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvDouble: { + PVDoubleArray *pvfrom = (PVDoubleArray*) from; + while (len > 0) { + int num = 0; + DoubleArrayData doubleArrayData = DoubleArrayData(); + num = pvfrom->get(offset, len, &doubleArrayData); + DoubleArray data = doubleArrayData.data; + int dataOffset = doubleArrayData.offset; + if (num <= 0) break; + while (num > 0) { + int n = convert->fromDoubleArray( + to, toOffset, num, data, dataOffset); + if (n <= 0) break; + len -= n; + num -= n; + ncopy += n; + offset += n; + toOffset += n; + } + } + break; + } + case pvString: + throw std::logic_error(String("PVStringArray is not a numeric array")); + } + return ncopy; +} + +class ConvertExt : public Convert { +public: + ConvertExt(): Convert(){}; +}; + +Convert * getConvert() { + static Mutex mutex = Mutex(); + Lock xx(&mutex); + + if(convert==0){ + convert = new ConvertExt(); + pvDataCreate = getPVDataCreate(); + } + return convert; +} + +}} diff --git a/pvDataApp/factory/AbstractPVField.h b/pvDataApp/factory/AbstractPVField.h index c30e5a0..fd07360 100644 --- a/pvDataApp/factory/AbstractPVField.h +++ b/pvDataApp/factory/AbstractPVField.h @@ -223,6 +223,7 @@ void PVField::toString(StringBuilder buf) {toString(buf,0);} void PVField::toString(StringBuilder buf,int indentLevel) { + getConvert()->getString(buf,this,indentLevel); if(pImpl->pvAuxInfo==0) return; pImpl->pvAuxInfo->toString(buf,indentLevel); } diff --git a/pvDataApp/factory/BasePVBoolean.h b/pvDataApp/factory/BasePVBoolean.h index 0ce3e55..ddb3391 100644 --- a/pvDataApp/factory/BasePVBoolean.h +++ b/pvDataApp/factory/BasePVBoolean.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher); virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -56,14 +54,6 @@ namespace epics { namespace pvData { value = pbuffer->getBoolean(); } - void BasePVBoolean::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVBoolean::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVBoolean::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVBooleanArray.h b/pvDataApp/factory/BasePVBooleanArray.h index 6d14259..51c8613 100644 --- a/pvDataApp/factory/BasePVBooleanArray.h +++ b/pvDataApp/factory/BasePVBooleanArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -175,18 +173,6 @@ namespace epics { namespace pvData { } } - void BasePVBooleanArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVBooleanArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVBooleanArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVByte.h b/pvDataApp/factory/BasePVByte.h index bb74d4a..7376ada 100644 --- a/pvDataApp/factory/BasePVByte.h +++ b/pvDataApp/factory/BasePVByte.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -55,14 +53,6 @@ namespace epics { namespace pvData { value = pbuffer->getByte(); } - void BasePVByte::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVByte::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVByte::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVByteArray.h b/pvDataApp/factory/BasePVByteArray.h index 14f168b..851b991 100644 --- a/pvDataApp/factory/BasePVByteArray.h +++ b/pvDataApp/factory/BasePVByteArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -175,18 +173,6 @@ namespace epics { namespace pvData { } } - void BasePVByteArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVByteArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVByteArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVDouble.h b/pvDataApp/factory/BasePVDouble.h index 518d9c4..3949d5e 100644 --- a/pvDataApp/factory/BasePVDouble.h +++ b/pvDataApp/factory/BasePVDouble.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -55,14 +53,6 @@ namespace epics { namespace pvData { value = pbuffer->getDouble(); } - void BasePVDouble::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVDouble::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVDouble::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVDoubleArray.h b/pvDataApp/factory/BasePVDoubleArray.h index 060f604..54f0d50 100644 --- a/pvDataApp/factory/BasePVDoubleArray.h +++ b/pvDataApp/factory/BasePVDoubleArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -178,18 +176,6 @@ namespace epics { namespace pvData { } } - void BasePVDoubleArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVDoubleArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVDoubleArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVFloat.h b/pvDataApp/factory/BasePVFloat.h index 3a6e6ce..69f673d 100644 --- a/pvDataApp/factory/BasePVFloat.h +++ b/pvDataApp/factory/BasePVFloat.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -55,14 +53,6 @@ namespace epics { namespace pvData { value = pbuffer->getFloat(); } - void BasePVFloat::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVFloat::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVFloat::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVFloatArray.h b/pvDataApp/factory/BasePVFloatArray.h index 0da1e0a..5c50fd6 100644 --- a/pvDataApp/factory/BasePVFloatArray.h +++ b/pvDataApp/factory/BasePVFloatArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -178,18 +176,6 @@ namespace epics { namespace pvData { } } - void BasePVFloatArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVFloatArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVFloatArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVInt.h b/pvDataApp/factory/BasePVInt.h index 51a5d99..28469c3 100644 --- a/pvDataApp/factory/BasePVInt.h +++ b/pvDataApp/factory/BasePVInt.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -55,14 +53,6 @@ namespace epics { namespace pvData { value = pbuffer->getInt(); } - void BasePVInt::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVInt::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVInt::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVIntArray.h b/pvDataApp/factory/BasePVIntArray.h index 3006a1e..b2935f7 100644 --- a/pvDataApp/factory/BasePVIntArray.h +++ b/pvDataApp/factory/BasePVIntArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -178,18 +176,6 @@ namespace epics { namespace pvData { } } - void BasePVIntArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVIntArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVIntArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVLong.h b/pvDataApp/factory/BasePVLong.h index 0544715..9be656c 100644 --- a/pvDataApp/factory/BasePVLong.h +++ b/pvDataApp/factory/BasePVLong.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -55,14 +53,6 @@ namespace epics { namespace pvData { value = pbuffer->getLong(); } - void BasePVLong::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVLong::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVLong::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVLongArray.h b/pvDataApp/factory/BasePVLongArray.h index 2a3da0a..7cd45ee 100644 --- a/pvDataApp/factory/BasePVLongArray.h +++ b/pvDataApp/factory/BasePVLongArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -178,18 +176,6 @@ namespace epics { namespace pvData { } } - void BasePVLongArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVLongArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVLongArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVShort.h b/pvDataApp/factory/BasePVShort.h index 72a8a11..111b2e9 100644 --- a/pvDataApp/factory/BasePVShort.h +++ b/pvDataApp/factory/BasePVShort.h @@ -25,8 +25,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -55,14 +53,6 @@ namespace epics { namespace pvData { value = pbuffer->getShort(); } - void BasePVShort::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVShort::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVShort::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVShortArray.h b/pvDataApp/factory/BasePVShortArray.h index 2913a81..18ef9b5 100644 --- a/pvDataApp/factory/BasePVShortArray.h +++ b/pvDataApp/factory/BasePVShortArray.h @@ -33,8 +33,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -178,18 +176,6 @@ namespace epics { namespace pvData { } } - void BasePVShortArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVShortArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVShortArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVString.h b/pvDataApp/factory/BasePVString.h index e0d6093..6319e56 100644 --- a/pvDataApp/factory/BasePVString.h +++ b/pvDataApp/factory/BasePVString.h @@ -26,8 +26,6 @@ namespace epics { namespace pvData { SerializableControl *pflusher) ; virtual void deserialize(ByteBuffer *pbuffer, DeserializableControl *pflusher); - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -54,14 +52,6 @@ namespace epics { namespace pvData { value = SerializeHelper::deserializeString(pbuffer, pflusher); } - void BasePVString::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVString::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - bool BasePVString::operator==(PVField& pvField) { return getConvert()->equals(this, &pvField); diff --git a/pvDataApp/factory/BasePVStringArray.h b/pvDataApp/factory/BasePVStringArray.h index 6c15c07..cb7564e 100644 --- a/pvDataApp/factory/BasePVStringArray.h +++ b/pvDataApp/factory/BasePVStringArray.h @@ -31,8 +31,6 @@ namespace epics { namespace pvData { virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher); virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) ; - virtual void toString(StringBuilder buf); - virtual void toString(StringBuilder buf,int indentLevel); virtual bool operator==(PVField& pv) ; virtual bool operator!=(PVField& pv) ; private: @@ -158,18 +156,6 @@ namespace epics { namespace pvData { SerializeHelper::serializeString(value[i], pbuffer, pflusher); } - void BasePVStringArray::toString(StringBuilder buf) - { - toString(buf,1); - } - - void BasePVStringArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - - PVField::toString(buf,indentLevel); - } - bool BasePVStringArray::operator==(PVField& pv) { return getConvert()->equals(this, &pv); diff --git a/pvDataApp/factory/BasePVStructure.h b/pvDataApp/factory/BasePVStructure.h index 12137c6..e023421 100644 --- a/pvDataApp/factory/BasePVStructure.h +++ b/pvDataApp/factory/BasePVStructure.h @@ -423,41 +423,6 @@ namespace epics { namespace pvData { return true; } - void PVStructure::toStringPvt(StringBuilder builder,int indentLevel) { - Convert *convert = getConvert(); - PVField::toString(builder,indentLevel); - if(pImpl->extendsStructureName.length()>0) { - *builder += " extends "; - *builder += pImpl->extendsStructureName; - } - convert->newLine(builder,indentLevel); - *builder += "{"; - int nFields = pImpl->numberFields; - PVFieldPtrArray pvFields = pImpl->pvFields; - for(int i=0; i < nFields; i++) { - PVField *pvField = pvFields[i]; - convert->newLine(builder,indentLevel + 1); - FieldConstPtr field = pvField->getField(); - *builder += field->getFieldName() + " = "; - pvField->toString(builder,indentLevel+1); - } - convert->newLine(builder,indentLevel); - *builder += "}"; - } - - void PVStructure::toString(StringBuilder buf) - { - *buf += "structure "; - *buf += getField()->getFieldName(); - toStringPvt(buf,0); - } - - void PVStructure::toString(StringBuilder buf,int indentLevel) - { - *buf += "structure "; - toStringPvt(buf,indentLevel); - } - void PVStructure::serialize(ByteBuffer *pbuffer, SerializableControl *pflusher) { for(int i = 0; inumberFields; i++) diff --git a/pvDataApp/factory/BasePVStructureArray.h b/pvDataApp/factory/BasePVStructureArray.h index 460a1bf..03505db 100644 --- a/pvDataApp/factory/BasePVStructureArray.h +++ b/pvDataApp/factory/BasePVStructureArray.h @@ -29,8 +29,6 @@ namespace epics { namespace pvData { StructureArrayData *data); virtual int put(int offset,int length, PVStructurePtrArray from, int fromOffset); - virtual void toString(StringBuilder buf) ; - virtual void toString(StringBuilder buf,int indentLevel) ; virtual bool operator==(PVField &pv); virtual bool operator!=(PVField &pv); virtual void shareData( PVStructurePtrArray value,int capacity,int length); @@ -53,11 +51,18 @@ namespace epics { namespace pvData { structureArray(structureArray), structureArrayData(new StructureArrayData()), value(new PVStructurePtr[0]) - {} + { + structureArray->incReferenceCount(); + } BasePVStructureArray::~BasePVStructureArray() { + structureArray->decReferenceCount(); delete structureArrayData; + int length = getLength(); + for(int i=0; icapacity) { setCapacity(newlength); + capacity = getCapacity(); newlength = capacity; len = newlength - offset; if(len<=0) return 0; @@ -147,14 +153,6 @@ namespace epics { namespace pvData { setLength(length); } - void BasePVStructureArray::toString(StringBuilder buf) {toString(buf,0);} - - void BasePVStructureArray::toString(StringBuilder buf,int indentLevel) - { - getConvert()->getString(buf,this,indentLevel); - PVField::toString(buf,indentLevel); - } - void BasePVStructureArray::serialize(ByteBuffer *pbuffer, SerializableControl *pflusher) { serialize(pbuffer, pflusher, 0, getLength()); diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp index 8828135..bb35e28 100644 --- a/pvDataApp/factory/Convert.cpp +++ b/pvDataApp/factory/Convert.cpp @@ -126,7 +126,7 @@ void Convert::fromString(PVScalar *pvScalar, String from) bool value = ((from.compare("true")==0) ? true : false); pv->put(value); - break; + return; } case pvByte : { PVByte *pv = (PVByte*)pvScalar; @@ -134,7 +134,7 @@ void Convert::fromString(PVScalar *pvScalar, String from) sscanf(from.c_str(),"%d",&ival); int8 value = ival; pv->put(value); - break; + return; } case pvShort : { PVShort *pv = (PVShort*)pvScalar; @@ -142,7 +142,7 @@ void Convert::fromString(PVScalar *pvScalar, String from) sscanf(from.c_str(),"%d",&ival); int16 value = ival; pv->put(value); - break; + return; } case pvInt : { PVInt *pv = (PVInt*)pvScalar; @@ -150,7 +150,7 @@ void Convert::fromString(PVScalar *pvScalar, String from) sscanf(from.c_str(),"%d",&ival); int32 value = ival; pv->put(value); - break; + return; } case pvLong : { PVLong *pv = (PVLong*)pvScalar; @@ -158,26 +158,26 @@ void Convert::fromString(PVScalar *pvScalar, String from) sscanf(from.c_str(),"%lld",&ival); int64 value = ival; pv->put(value); - break; + return; } case pvFloat : { PVFloat *pv = (PVFloat*)pvScalar; float value; sscanf(from.c_str(),"%f",&value); pv->put(value); - break; + return; } case pvDouble : { PVDouble*pv = (PVDouble*)pvScalar; double value; sscanf(from.c_str(),"%lf",&value); pv->put(value); - break; + return; } case pvString: { PVString *value = (PVString*)pvScalar; value->put(from); - break; + return; } } String message("Convert::fromString unknown scalarType "); @@ -3056,7 +3056,13 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel) return convertStructureArray(buffer,(PVStructureArray*)pv,indentLevel); } PVScalar *pvScalar = (PVScalar*)pv; - switch(pvScalar->getScalar()->getScalarType()) { + ScalarConstPtr pscalar = pvScalar->getScalar(); + ScalarType scalarType = pscalar->getScalarType(); + ScalarTypeFunc::toString(buffer,scalarType); + *buffer += " "; + *buffer += pscalar->getFieldName(); + *buffer += " "; + switch(scalarType) { case pvBoolean: { PVBoolean *data = (PVBoolean*)pv; bool value = data->get(); @@ -3121,30 +3127,28 @@ void convertToString(StringBuilder buffer,PVField * pv,int indentLevel) void convertStructure(StringBuilder buffer,PVStructure *data,int indentLevel) { - convert->newLine(buffer, indentLevel); - *buffer += "structure {"; + *buffer += "structure "; + *buffer += data->getField()->getFieldName(); + convert->newLine(buffer, indentLevel+1); PVFieldPtrArray fieldsData = data->getPVFields(); if (fieldsData != 0) { int length = data->getStructure()->getNumberFields(); for(int i=0; igetField(); - convert->newLine(buffer, indentLevel + 1); - int size = fieldnow->getFieldName().length(); - char buff[size+2]; - sprintf(buff,"%s = ",fieldnow->getFieldName().c_str()); - *buffer += buff; - convert->getString(buffer,fieldField,indentLevel + 1); + fieldField->toString(buffer,indentLevel + 1); + if(inewLine(buffer, indentLevel+1); } } - convert->newLine(buffer, indentLevel); - *buffer += "}"; } void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel) { ScalarArrayConstPtr array = pv->getScalarArray(); ScalarType type = array->getElementType(); + ScalarTypeFunc::toString(buffer,type); + *buffer += "Array "; + *buffer += array->getFieldName(); + *buffer += " "; switch(type) { case pvBoolean: { PVBooleanArray *pvdata = (PVBooleanArray*)pv; @@ -3313,9 +3317,17 @@ void convertArray(StringBuilder buffer,PVScalarArray * pv,int indentLevel) void convertStructureArray(StringBuilder buffer, PVStructureArray * pvdata,int indentLevel) { + *buffer += "structureArray "; + *buffer += pvdata->getField()->getFieldName(); + *buffer += " "; StructureArrayData data = StructureArrayData(); int length = pvdata->getLength(); pvdata->get(0, length, &data); + if(length<=0) { + *buffer += " []"; + return; + } + convert->newLine(buffer, indentLevel); *buffer += "["; for (int i = 0; i < length; i++) { if (i != 0) { diff --git a/pvDataApp/factory/StandardPVField.cpp b/pvDataApp/factory/StandardPVField.cpp index e3e088e..4681900 100644 --- a/pvDataApp/factory/StandardPVField.cpp +++ b/pvDataApp/factory/StandardPVField.cpp @@ -59,7 +59,7 @@ PVStructureArray * StandardPVField::structureArray(PVStructure *parent, return pvDataCreate->createPVStructureArray(parent,field); } -PVStructure * StandardPVField::structureArray(PVStructure *parent, +PVStructure* StandardPVField::structureArray(PVStructure *parent, String fieldName,StructureConstPtr structure,String properties) { StructureConstPtr field = standardField->structureArray( diff --git a/pvDataApp/misc/Makefile b/pvDataApp/misc/Makefile index d91e177..ee9acff 100644 --- a/pvDataApp/misc/Makefile +++ b/pvDataApp/misc/Makefile @@ -2,7 +2,7 @@ TOP=../.. include $(TOP)/configure/CONFIG -INC += pvTypes.h +INC += pvType.h INC += noDefaultMethods.h INC += lock.h INC += requester.h diff --git a/pvDataApp/misc/bitSet.h b/pvDataApp/misc/bitSet.h index 4360a94..3fad16e 100644 --- a/pvDataApp/misc/bitSet.h +++ b/pvDataApp/misc/bitSet.h @@ -2,7 +2,7 @@ #ifndef BITSET_H #define BITSET_H #include -#include +#include //#include "byteBuffer.h" //#include "serialize.h" namespace epics { namespace pvData { diff --git a/pvDataApp/misc/byteBuffer.h b/pvDataApp/misc/byteBuffer.h index b25b1f9..d3c74f2 100644 --- a/pvDataApp/misc/byteBuffer.h +++ b/pvDataApp/misc/byteBuffer.h @@ -3,7 +3,7 @@ #define BYTEBUFFER_H #include -#include +#include #include namespace epics { diff --git a/pvDataApp/misc/pvTypes.h b/pvDataApp/misc/pvType.h similarity index 76% rename from pvDataApp/misc/pvTypes.h rename to pvDataApp/misc/pvType.h index c1669ba..bc76ec6 100644 --- a/pvDataApp/misc/pvTypes.h +++ b/pvDataApp/misc/pvType.h @@ -1,6 +1,6 @@ -/* pvTypes.h */ -#ifndef PVTYPES_H -#define PVTYPES_H +/* pvType.h */ +#ifndef PVTYPE_H +#define PVTYPE_H namespace epics { namespace pvData { @@ -12,7 +12,7 @@ namespace epics { namespace pvData { typedef unsigned long long uint64; }} -#endif /* PVTYPES_H */ +#endif /* PVTYPE_H */ diff --git a/pvDataApp/misc/serializeHelper.cpp b/pvDataApp/misc/serializeHelper.cpp index 7428ec4..e05512d 100644 --- a/pvDataApp/misc/serializeHelper.cpp +++ b/pvDataApp/misc/serializeHelper.cpp @@ -6,7 +6,7 @@ */ #include -#include +#include #include "epicsException.h" #include "byteBuffer.h" diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h index 204d2a9..981ab6e 100644 --- a/pvDataApp/pv/pvData.h +++ b/pvDataApp/pv/pvData.h @@ -101,8 +101,6 @@ namespace epics { namespace pvData { public: virtual ~PVScalar(); ScalarConstPtr getScalar() ; - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; protected: PVScalar(PVStructure *parent,ScalarConstPtr scalar); }; @@ -122,8 +120,6 @@ namespace epics { namespace pvData { DeserializableControl *pflusher) = 0; virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) = 0; - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; protected: PVArray(PVStructure *parent,FieldConstPtr field); void setCapacityLength(int capacity,int length); @@ -143,8 +139,6 @@ namespace epics { namespace pvData { DeserializableControl *pflusher) = 0; virtual void serialize(ByteBuffer *pbuffer, SerializableControl *pflusher, int offset, int count) = 0; - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; protected: PVScalarArray(PVStructure *parent,ScalarArrayConstPtr scalarArray); private: @@ -208,8 +202,6 @@ namespace epics { namespace pvData { String getExtendsStructureName(); bool putExtendsStructureName( String extendsStructureName); - virtual void toString(StringBuilder buf) ; - virtual void toString(StringBuilder buf,int indentLevel) ; virtual bool operator==(PVField &pv) ; virtual bool operator!=(PVField &pv) ; virtual void serialize( @@ -225,7 +217,6 @@ namespace epics { namespace pvData { protected: PVStructure(PVStructure *parent,StructureConstPtr structure); private: - void toStringPvt(StringBuilder buf,int indentLevel) ; class PVStructurePvt * pImpl; }; @@ -328,8 +319,6 @@ namespace epics { namespace pvData { class PVBooleanArray : public PVScalarArray { public: virtual ~PVBooleanArray(); - virtual void toString(StringBuilder buf) = 0 ; - virtual void toString(StringBuilder buf,int indentLevel) = 0 ; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, BooleanArrayData *data) = 0; virtual int put(int offset,int length, BooleanArray from, int fromOffset) = 0; @@ -352,8 +341,6 @@ namespace epics { namespace pvData { class PVByteArray : public PVScalarArray { public: virtual ~PVByteArray(); - virtual void toString(StringBuilder buf) = 0 ; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, ByteArrayData *data) = 0; virtual int put(int offset,int length, ByteArray from, int fromOffset) = 0; @@ -376,8 +363,6 @@ namespace epics { namespace pvData { class PVShortArray : public PVScalarArray { public: virtual ~PVShortArray(); - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, ShortArrayData *data) = 0; virtual int put(int offset,int length, ShortArray from, int fromOffset) = 0; @@ -399,8 +384,6 @@ namespace epics { namespace pvData { class PVIntArray : public PVScalarArray { public: virtual ~PVIntArray(); - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, IntArrayData *data) = 0; virtual int put(int offset,int length, IntArray from, int fromOffset)= 0; @@ -423,8 +406,6 @@ namespace epics { namespace pvData { class PVLongArray : public PVScalarArray { public: virtual ~PVLongArray(); - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, LongArrayData *data) = 0; virtual int put(int offset,int length, LongArray from, int fromOffset)= 0; @@ -447,8 +428,6 @@ namespace epics { namespace pvData { class PVFloatArray : public PVScalarArray { public: virtual ~PVFloatArray(); - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, FloatArrayData *data) = 0; virtual int put(int offset,int length, FloatArray from, int fromOffset)= 0; @@ -473,8 +452,6 @@ namespace epics { namespace pvData { class PVDoubleArray : public PVScalarArray { public: virtual ~PVDoubleArray(); - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, DoubleArrayData *data) = 0; virtual int put(int offset,int length, DoubleArray from, int fromOffset) = 0; @@ -497,8 +474,6 @@ namespace epics { namespace pvData { class PVStringArray : public PVScalarArray { public: virtual ~PVStringArray(); - virtual void toString(StringBuilder buf) = 0; - virtual void toString(StringBuilder buf,int indentLevel) = 0; virtual void setCapacity(int capacity) = 0; virtual int get(int offset, int length, StringArrayData *data) = 0; virtual int put(int offset,int length, StringArray from, int fromOffset)= 0; diff --git a/pvDataApp/pv/pvIntrospect.h b/pvDataApp/pv/pvIntrospect.h index 1ca4844..84c67c0 100644 --- a/pvDataApp/pv/pvIntrospect.h +++ b/pvDataApp/pv/pvIntrospect.h @@ -4,7 +4,7 @@ #ifndef PVINTROSPECT_H #define PVINTROSPECT_H #include "noDefaultMethods.h" -#include "pvTypes.h" +#include "pvType.h" namespace epics { namespace pvData { class Field; @@ -76,6 +76,7 @@ namespace epics { namespace pvData { friend class Structure; friend class PVFieldPvt; friend class StandardField; + friend class BasePVStructureArray; }; diff --git a/pvDataApp/pv/standardPVField.h b/pvDataApp/pv/standardPVField.h index 05db558..70258c2 100644 --- a/pvDataApp/pv/standardPVField.h +++ b/pvDataApp/pv/standardPVField.h @@ -21,7 +21,7 @@ namespace epics { namespace pvData { String fieldName,ScalarType elementType, String properties); PVStructureArray * structureArray(PVStructure *parent, String fieldName,StructureConstPtr structure); - PVStructure * structureArray(PVStructure *parent, + PVStructure* structureArray(PVStructure *parent, String fieldName,StructureConstPtr structure,String properties); PVStructure * enumerated(PVStructure *parent, String fieldName,StringArray choices); diff --git a/pvDataApp/pvTest/Makefile b/pvDataApp/pvTest/Makefile index 36b4285..8c2065b 100644 --- a/pvDataApp/pvTest/Makefile +++ b/pvDataApp/pvTest/Makefile @@ -2,17 +2,21 @@ TOP=../.. include $(TOP)/configure/CONFIG -PROD_HOST += testIntTypes -testIntTypes_SRCS += testIntTypes.cpp -testIntTypes_LIBS += pvFactory Com +PROD_HOST += testPVType +testPVType_SRCS += testPVType.cpp +testPVType_LIBS += pvFactory Com PROD_HOST += testIntrospect testIntrospect_SRCS += testIntrospect.cpp testIntrospect_LIBS += pvFactory Com -PROD_HOST += testSimple -testSimple_SRCS += testSimple.cpp -testSimple_LIBS += pvFactory Com +PROD_HOST += testPVData +testPVData_SRCS += testPVData.cpp +testPVData_LIBS += pvFactory Com + +PROD_HOST += testPVStructureArray +testPVStructureArray_SRCS += testPVStructureArray.cpp +testPVStructureArray_LIBS += pvFactory Com include $(TOP)/configure/RULES #---------------------------------------- diff --git a/pvDataApp/pvTest/testIntrospect.cpp b/pvDataApp/pvTest/testIntrospect.cpp index 97c9e2c..a02d47c 100644 --- a/pvDataApp/pvTest/testIntrospect.cpp +++ b/pvDataApp/pvTest/testIntrospect.cpp @@ -156,8 +156,8 @@ int main(int argc,char *argv[]) finalTotalReferences = Field::getTotalReferenceCount(); assert(initialTotalReferences==finalTotalReferences); initialTotalReferences = Field::getTotalReferenceCount(); - long long totalConstruct = Field::getTotalConstruct(); - long long totalDestruct = Field::getTotalDestruct(); + int64 totalConstruct = Field::getTotalConstruct(); + int64 totalDestruct = Field::getTotalDestruct(); int totalReference = Field::getTotalReferenceCount(); fprintf(fd,"Field: totalConstruct %lli totalDestruct %lli totalReferenceCount %i\n", totalConstruct,totalDestruct,totalReference); diff --git a/pvDataApp/pvTest/testPVData.cpp b/pvDataApp/pvTest/testPVData.cpp new file mode 100644 index 0000000..b9d8498 --- /dev/null +++ b/pvDataApp/pvTest/testPVData.cpp @@ -0,0 +1,283 @@ +/* testPVdata.cpp */ +/* Author: Marty Kraimer Date: 2010.11 */ + +#include +#include +#include +#include +#include + +#include + +#include "requester.h" +#include "pvIntrospect.h" +#include "pvData.h" +#include "convert.h" +#include "standardField.h" +#include "standardPVField.h" + +using namespace epics::pvData; + +static FieldCreate * fieldCreate = 0; +static PVDataCreate * pvDataCreate = 0; +static StandardField *standardField = 0; +static StandardPVField *standardPVField = 0; +static Convert *convert = 0; +static String builder(""); +static String alarmTimeStamp("alarm,timeStamp"); +static String alarmTimeStampValueAlarm("alarm,timeStamp,valueAlarm"); +static String allProperties("alarm,timeStamp,display,control,valueAlarm"); + +static void testPVScalarCommon(FILE * fd,String fieldName,ScalarType stype) +{ + PVScalar *pvScalar = standardPVField->scalar(0,fieldName,stype); + if(stype==pvBoolean) { + convert->fromString(pvScalar,String("true")); + } else { + convert->fromString(pvScalar,String("10")); + } + builder.clear(); + pvScalar->toString(&builder); + fprintf(fd,"%s\n",builder.c_str()); + delete pvScalar; +} + +static void testPVScalarWithProperties( + FILE * fd,String fieldName,ScalarType stype) +{ + PVStructure *pvStructure = 0; + bool hasValueAlarm = false; + bool hasDisplayControl = false; + switch(stype) { + case pvBoolean: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,alarmTimeStampValueAlarm); + hasValueAlarm = true; + PVBoolean *pvField = pvStructure->getBooleanField(String("value")); + pvField->put(true); + break; + } + case pvByte: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,allProperties); + hasValueAlarm = true; + hasDisplayControl = true; + PVByte *pvField = pvStructure->getByteField(String("value")); + pvField->put(127); + break; + } + case pvShort: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,allProperties); + hasValueAlarm = true; + hasDisplayControl = true; + PVShort *pvField = pvStructure->getShortField(String("value")); + pvField->put(32767); + break; + } + case pvInt: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,allProperties); + hasValueAlarm = true; + hasDisplayControl = true; + PVInt *pvField = pvStructure->getIntField(String("value")); + pvField->put((int)0x80000000); + break; + } + case pvLong: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,allProperties); + hasValueAlarm = true; + hasDisplayControl = true; + PVLong *pvField = pvStructure->getLongField(String("value")); + int64 value = 0x80000000; + value <<= 32; + value |= 0xffffffff; + pvField->put(value); + break; + } + case pvFloat: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,allProperties); + hasValueAlarm = true; + hasDisplayControl = true; + PVFloat *pvField = pvStructure->getFloatField(String("value")); + pvField->put(1.123e8); + break; + } + case pvDouble: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,allProperties); + hasValueAlarm = true; + hasDisplayControl = true; + PVDouble *pvField = pvStructure->getDoubleField(String("value")); + pvField->put(1.123e35); + break; + } + case pvString: { + pvStructure = standardPVField->scalar( + 0,fieldName,stype,alarmTimeStamp); + PVString *pvField = pvStructure->getStringField(String("value")); + pvField->put(String("this is a string")); + break; + } + } + PVLong *seconds = pvStructure->getLongField( + String("timeStamp.secondsPastEpoch")); + assert(seconds!=0); + seconds->put(123456789); + PVInt *nano = pvStructure->getIntField(String("timeStamp.nanoSeconds")); + assert(nano!=0); + nano->put(1000000); + PVInt *severity = pvStructure->getIntField(String("alarm.severity")); + assert(severity!=0); + severity->put(2); + PVString *message = pvStructure->getStringField(String("alarm.message")); + assert(message!=0); + message->put(String("messageForAlarm")); + if(hasDisplayControl) { + PVString *desc = pvStructure->getStringField( + String("display.description")); + assert(desc!=0); + desc->put(String("this is a description")); + PVString *format = pvStructure->getStringField( + String("display.format")); + assert(format!=0); + format->put(String("f10.2")); + PVString *units = pvStructure->getStringField( + String("display.units")); + assert(units!=0); + units->put(String("SomeUnits")); + PVDouble *limit = pvStructure->getDoubleField( + String("display.limit.low")); + assert(limit!=0); + limit->put(0.0); + limit = pvStructure->getDoubleField( + String("display.limit.high")); + assert(limit!=0); + limit->put(10.0); + limit = pvStructure->getDoubleField( + String("control.limit.low")); + assert(limit!=0); + limit->put(1.0); + limit = pvStructure->getDoubleField( + String("control.limit.high")); + assert(limit!=0); + limit->put(9.0); + PVScalar *pvtemp = (PVScalar *)pvStructure->getSubField( + String("valueAlarm.lowAlarmLimit")); + assert(pvtemp!=0); + convert->fromDouble(pvtemp,1.0); + pvtemp = (PVScalar *)pvStructure->getSubField( + String("valueAlarm.highAlarmLimit")); + assert(pvtemp!=0); + convert->fromDouble(pvtemp,9.0); + severity = pvStructure->getIntField( + String("valueAlarm.lowAlarmSeverity")); + assert(severity!=0); + severity->put(2); + severity = pvStructure->getIntField( + String("valueAlarm.highAlarmSeverity")); + assert(severity!=0); + severity->put(2); + PVBoolean *active = pvStructure->getBooleanField( + String("valueAlarm.active")); + assert(active!=0); + active->put(true); + } + builder.clear(); + pvStructure->toString(&builder); + fprintf(fd,"%s\n",builder.c_str()); + delete pvStructure; +} + +static void testPVScalar(FILE * fd) { + fprintf(fd,"\ntestScalar\n"); + testPVScalarCommon(fd,String("boolean"),pvBoolean); + testPVScalarCommon(fd,String("byte"),pvByte); + testPVScalarCommon(fd,String("short"),pvShort); + testPVScalarCommon(fd,String("int"),pvInt); + testPVScalarCommon(fd,String("long"),pvLong); + testPVScalarCommon(fd,String("float"),pvFloat); + testPVScalarCommon(fd,String("double"),pvDouble); + testPVScalarCommon(fd,String("string"),pvString); + + testPVScalarWithProperties(fd,String("boolean"),pvBoolean); + testPVScalarWithProperties(fd,String("byte"),pvByte); + testPVScalarWithProperties(fd,String("short"),pvShort); + testPVScalarWithProperties(fd,String("int"),pvInt); + testPVScalarWithProperties(fd,String("long"),pvLong); + testPVScalarWithProperties(fd,String("float"),pvFloat); + testPVScalarWithProperties(fd,String("double"),pvDouble); + testPVScalarWithProperties(fd,String("string"),pvString); +} + +static void testScalarArrayCommon(FILE * fd,String fieldName,ScalarType stype) +{ + PVStructure *pvStructure = standardPVField->scalarArray( + 0,fieldName,stype,alarmTimeStamp); + PVScalarArray *scalarArray = pvStructure->getScalarArrayField( + String("value"),stype); + assert(scalarArray!=0); + if(stype==pvBoolean) { + String values[] = {String("true"),String("false"),String("true")}; + convert->fromStringArray(scalarArray, 0,3,values,0); + } else { + String values[] = {String("0"),String("1"),String("2")}; + convert->fromStringArray(scalarArray, 0,3,values,0); + } + builder.clear(); + pvStructure->toString(&builder); + fprintf(fd,"%s\n",builder.c_str()); + delete pvStructure; +} + +static void testScalarArray(FILE * fd) { + fprintf(fd,"\ntestScalarArray\n"); + testScalarArrayCommon(fd,String("boolean"),pvBoolean); + testScalarArrayCommon(fd,String("byte"),pvByte); + testScalarArrayCommon(fd,String("short"),pvShort); + testScalarArrayCommon(fd,String("int"),pvInt); + testScalarArrayCommon(fd,String("long"),pvLong); + testScalarArrayCommon(fd,String("float"),pvFloat); + testScalarArrayCommon(fd,String("double"),pvDouble); + testScalarArrayCommon(fd,String("string"),pvString); +} + + +int main(int argc,char *argv[]) +{ + int initialTotalReferences,finalTotalReferences; + char *fileName = 0; + if(argc>1) fileName = argv[1]; + FILE * fd = stdout; + if(fileName!=0 && fileName[0]!=0) { + fd = fopen(fileName,"w+"); + } + fieldCreate = getFieldCreate(); + pvDataCreate = getPVDataCreate(); + standardField = getStandardField(); + standardPVField = getStandardPVField(); + convert = getConvert(); + initialTotalReferences = Field::getTotalReferenceCount(); + testPVScalar(fd); + finalTotalReferences = Field::getTotalReferenceCount(); + assert(initialTotalReferences==finalTotalReferences); + initialTotalReferences = Field::getTotalReferenceCount(); + testScalarArray(fd); + finalTotalReferences = Field::getTotalReferenceCount(); + assert(initialTotalReferences==finalTotalReferences); + int64 totalConstruct = Field::getTotalConstruct(); + int64 totalDestruct = Field::getTotalDestruct(); + int totalReference = Field::getTotalReferenceCount(); + fprintf(fd,"Field: totalConstruct %lli totalDestruct %lli totalReferenceCount %i\n", + totalConstruct,totalDestruct,totalReference); + assert(totalConstruct==(totalDestruct+totalReference)); + totalConstruct = PVField::getTotalConstruct(); + totalDestruct = PVField::getTotalDestruct(); + fprintf(fd,"PVField: totalConstruct %lli totalDestruct %lli\n", + totalConstruct,totalDestruct); + assert(totalConstruct==totalDestruct); + return(0); +} + diff --git a/pvDataApp/pvTest/testPVStructureArray.cpp b/pvDataApp/pvTest/testPVStructureArray.cpp new file mode 100644 index 0000000..a873ff8 --- /dev/null +++ b/pvDataApp/pvTest/testPVStructureArray.cpp @@ -0,0 +1,85 @@ +/* testPVStructureArray.cpp */ +/* Author: Marty Kraimer Date: 2010.10 */ + +#include +#include +#include +#include +#include + +#include + +#include "requester.h" +#include "pvIntrospect.h" +#include "pvData.h" +#include "standardField.h" +#include "standardPVField.h" + +using namespace epics::pvData; + +static FieldCreate * fieldCreate = 0; +static PVDataCreate * pvDataCreate = 0; +static StandardField *standardField = 0; +static StandardPVField *standardPVField = 0; +static String buffer(""); + +StructureConstPtr getPowerSupplyStructure() { + String properties("alarm"); + FieldConstPtr powerSupply[3]; + powerSupply[0] = standardField->scalar( + String("voltage"),pvDouble,properties); + powerSupply[1] = standardField->scalar( + String("power"),pvDouble,properties); + powerSupply[2] = standardField->scalar( + String("current"),pvDouble,properties); + StructureConstPtr structure = standardField->structure( + String("powerSupply"),3,powerSupply); + return structure; +} + +void testPowerSupplyArray(FILE * fd) { + PVStructure* powerSupplyArrayStruct = standardPVField->structureArray( + 0,"powerSupply",getPowerSupplyStructure(),String("alarm,timeStamp")); + PVStructureArray * powerSupplyArray = + powerSupplyArrayStruct->getStructureArrayField(String("value")); + assert(powerSupplyArray!=0); + PVStructure *structureArray[3]; + StructureConstPtr structure = + powerSupplyArray->getStructureArray()->getStructure(); + structureArray[0] = pvDataCreate->createPVStructure(0,structure); + structureArray[1] = pvDataCreate->createPVStructure(0,structure); + structureArray[2] = pvDataCreate->createPVStructure(0,structure); + powerSupplyArray->put(0,3,structureArray,0); + buffer.clear(); + powerSupplyArrayStruct->toString(&buffer); + fprintf(fd,"%s\n",buffer.c_str()); + delete powerSupplyArrayStruct; +} + +int main(int argc,char *argv[]) +{ + char *fileName = 0; + if(argc>1) fileName = argv[1]; + FILE * fd = stdout; + if(fileName!=0 && fileName[0]!=0) { + fd = fopen(fileName,"w+"); + } + fieldCreate = getFieldCreate(); + pvDataCreate = getPVDataCreate(); + standardField = getStandardField(); + standardPVField = getStandardPVField(); + testPowerSupplyArray(fd); + int64 totalConstruct = Field::getTotalConstruct(); + int64 totalDestruct = Field::getTotalDestruct(); + int totalReference = Field::getTotalReferenceCount(); + fprintf(fd,"Field: totalConstruct %lli totalDestruct %lli totalReferenceCount %i\n", + totalConstruct,totalDestruct,totalReference); + assert(totalConstruct==(totalDestruct+totalReference)); + totalConstruct = PVField::getTotalConstruct(); + totalDestruct = PVField::getTotalDestruct(); + fprintf(fd,"PVField: totalConstruct %lli totalDestruct %lli\n", + totalConstruct,totalDestruct); + assert(totalConstruct==totalDestruct); + return(0); +} + diff --git a/pvDataApp/pvTest/testIntTypes.cpp b/pvDataApp/pvTest/testPVType.cpp similarity index 98% rename from pvDataApp/pvTest/testIntTypes.cpp rename to pvDataApp/pvTest/testPVType.cpp index 0fea2f4..a4305da 100644 --- a/pvDataApp/pvTest/testIntTypes.cpp +++ b/pvDataApp/pvTest/testPVType.cpp @@ -10,7 +10,7 @@ #include #include "requester.h" -#include "pvTypes.h" +#include "pvType.h" using namespace epics::pvData; diff --git a/pvDataApp/pvTest/testSimple.cpp b/pvDataApp/pvTest/testSimple.cpp deleted file mode 100644 index e8d8d50..0000000 --- a/pvDataApp/pvTest/testSimple.cpp +++ /dev/null @@ -1,92 +0,0 @@ -/* testSimpleStructure.cpp */ -/* Author: Marty Kraimer Date: 2010.09 */ - -#include -#include -#include -#include -#include - -#include - -#include "requester.h" -#include "pvIntrospect.h" -#include "pvData.h" -#include "standardField.h" -#include "standardPVField.h" - -using namespace epics::pvData; - -static FieldCreate * fieldCreate = 0; -static PVDataCreate * pvDataCrete = 0; -static StandardField *standardField = 0; -static StandardPVField *standardPVField = 0; -static String buffer(""); - - -void testSimpleStructure(FILE * fd) { - int initialTotalReferences,finalTotalReferences; - fprintf(fd,"\ntestSimpleStructure\n"); - String properties("alarm,timeStamp,display,control,valueAlarm"); - initialTotalReferences = Field::getTotalReferenceCount(); - PVStructure *ptop = standardPVField->scalar( - 0,String(""),pvDouble,properties); - buffer.clear(); - ptop->toString(&buffer); - fprintf(fd,"%s\n",buffer.c_str()); - finalTotalReferences = Field::getTotalReferenceCount(); - printf("before delete initialTotalReferences %d finalTotalReferences %d\n", - initialTotalReferences,finalTotalReferences); - delete ptop; - finalTotalReferences = Field::getTotalReferenceCount(); - printf("after initialTotalReferences %d finalTotalReferences %d\n", - initialTotalReferences,finalTotalReferences); - assert(initialTotalReferences==finalTotalReferences); -} - -void testPowerSupply(FILE * fd) { - int initialTotalReferences,finalTotalReferences; - fprintf(fd,"\ntestPowerSupply\n"); - initialTotalReferences = Field::getTotalReferenceCount(); - PVStructure *ptop = standardPVField->powerSupply(0); - buffer.clear(); - ptop->toString(&buffer); - fprintf(fd,"%s\n",buffer.c_str()); - finalTotalReferences = Field::getTotalReferenceCount(); - printf("before delete initialTotalReferences %d finalTotalReferences %d\n", - initialTotalReferences,finalTotalReferences); - delete ptop; - finalTotalReferences = Field::getTotalReferenceCount(); - printf("after initialTotalReferences %d finalTotalReferences %d\n", - initialTotalReferences,finalTotalReferences); - assert(initialTotalReferences==finalTotalReferences); -} - -int main(int argc,char *argv[]) -{ - char *fileName = 0; - if(argc>1) fileName = argv[1]; - FILE * fd = stdout; - if(fileName!=0 && fileName[0]!=0) { - fd = fopen(fileName,"w+"); - } - fieldCreate = getFieldCreate(); - pvDataCrete = getPVDataCreate(); - standardField = getStandardField(); - standardPVField = getStandardPVField(); - testSimpleStructure(fd); - testPowerSupply(fd); - long long totalConstruct = Field::getTotalConstruct(); - long long totalDestruct = Field::getTotalDestruct(); - int totalReference = Field::getTotalReferenceCount(); - printf("Field: totalConstruct %lli totalDestruct %lli totalReferenceCount %i\n", - totalConstruct,totalDestruct,totalReference); - assert(totalConstruct==(totalDestruct+totalReference)); - totalConstruct = PVField::getTotalConstruct(); - totalDestruct = PVField::getTotalDestruct(); - printf("PVField: totalConstruct %lli totalDestruct %lli\n", - totalConstruct,totalDestruct); - assert(totalConstruct==totalDestruct); - return(0); -} - diff --git a/pvDataApp/test/Makefile b/pvDataApp/test/Makefile index 66a83cb..0efb4f3 100644 --- a/pvDataApp/test/Makefile +++ b/pvDataApp/test/Makefile @@ -6,19 +6,6 @@ PROD_HOST += testPVAuxInfo testPVAuxInfo_SRCS += testPVAuxInfo.cpp testPVAuxInfo_LIBS += pvFactory -PROD_HOST += testPVScalar -testPVScalar_SRCS += testPVScalar.cpp -testPVScalar_LIBS += pvFactory -testPVScalar_LIBS += pvMisc Com - -PROD_HOST += testPVScalarArray -testPVScalarArray_SRCS += testPVScalarArray.cpp -testPVScalarArray_LIBS += pvFactory - -PROD_HOST += testSimpleStructure -testSimpleStructure_SRCS += testSimpleStructure.cpp -testSimpleStructure_LIBS += pvFactory - PROD_HOST += testBitSet testBitSet_SRCS += testBitSet.cpp testBitSet_LIBS += pvMisc Com diff --git a/pvDataApp/test/testPVScalar.cpp b/pvDataApp/test/testPVScalar.cpp deleted file mode 100644 index c76beb4..0000000 --- a/pvDataApp/test/testPVScalar.cpp +++ /dev/null @@ -1,359 +0,0 @@ -/* testPVscalar.cpp */ -/* Author: Marty Kraimer Date: 2010.09 */ - -#include -#include -#include -#include -#include -#include - -#include "requester.h" -#include "pvIntrospect.h" -#include "pvData.h" -#include "standardField.h" -#include "standardPVField.h" - -using namespace epics::pvData; - -static FieldCreate * pfieldCreate = 0; -static PVDataCreate *pvDataCreate = 0; -static String buffer(""); - -void testBoolean() { - printf("\ntestBoolean\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvBoolean); - PVBoolean *pvValue = (PVBoolean *)pvScalar; - bool value = true; - pvValue->put(value); - bool getValue = pvValue->get(); - printf("put %s get %s\n", - ((value==false) ? "false" : "true"), - ((getValue==false) ? "false" : "true")); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %s get %s\n", - ((value==false) ? "false" : "true"), - ((getValue==false) ? "false" : "true")); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardPVField()->scalarValue(0,pvDouble); - bool isEqual = pvScalar==other; - printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testByte() { - printf("\ntestByte\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvByte); - PVByte *pvValue = (PVByte *)pvScalar; - int8 value = 2; - pvValue->put(value); - int getValue = pvValue->get(); - printf("put %d get %d\n",value,getValue); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %d get %d\n",value,getValue); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardPVField()->scalarValue(0,pvDouble); - bool isEqual = pvScalar==other; - printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testShort() { - printf("\ntestShort\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvShort); - PVShort *pvValue = (PVShort *)pvScalar; - int16 value = 2; - pvValue->put(value); - int getValue = pvValue->get(); - printf("put %d get %d\n",value,getValue); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %d get %d\n",value,getValue); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardPVField()->scalarValue(0,pvDouble); - bool isEqual = pvScalar==other; - printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testInt() { - printf("\ntestInt\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvInt); - PVInt *pvValue = (PVInt *)pvScalar; - int32 value = 2; - pvValue->put(value); - int getValue = pvValue->get(); - printf("put %d get %d\n",value,getValue); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %d get %d\n",value,getValue); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardPVField()->scalarValue(0,pvDouble); - bool isEqual = pvScalar==other; - printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testLong() { - printf("\ntestLong\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvLong); - PVLong *pvValue = (PVLong *)pvScalar; - int64 value = 2; - pvValue->put(value); - int64 getValue = pvValue->get(); - printf("put %ld get %ld\n",(long int)value,(long int)getValue); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %ld get %ld\n",(long int)value,(long int)getValue); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - PVScalar *other = getStandardPVField()->scalarValue(0,pvDouble); - bool isEqual = pvScalar==other; - printf("expect false isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testFloat() { - printf("\ntestFloat\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvFloat); - PVFloat *pvValue = (PVFloat *)pvScalar; - float value = 2; - pvValue->put(value); - float getValue = pvValue->get(); - printf("put %f get %f\n",value,getValue); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %f get %f\n",value,getValue); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - bool isEqual = pvScalar==pvScalar; - printf("expect true isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testDouble() { - printf("\ntestDouble\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvDouble); - PVDouble *pvValue = (PVDouble *)pvScalar; - double value = 2; - pvValue->put(value); - double getValue = pvValue->get(); - printf("put %lf get %lf\n",value,getValue); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %lf get %lf\n",value,getValue); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - bool isEqual = pvScalar==pvScalar; - printf("expect true isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -void testString() { - printf("\ntestString\n"); - PVScalar *pvScalar = getStandardPVField()->scalarValue(0,pvString); - PVString *pvValue = (PVString *)pvScalar; - String value = "testString"; - pvValue->put(value); - String getValue = pvValue->get(); - printf("put %s get %s\n",value.c_str(),getValue.c_str()); - if(value!=getValue) { - fprintf(stderr,"ERROR getValue put %s get %s\n", - value.c_str(),getValue.c_str()); - } - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - bool isImmutable = pvValue->isImmutable(); - PVStructure *pvParent = pvValue->getParent(); - printf("immutable %s parent %p\n", - ((isImmutable==false) ? "false" : "true"), - pvParent); - int offset = pvValue->getFieldOffset(); - int nextOffset = pvValue->getNextFieldOffset(); - int numberFields = pvValue->getNumberFields(); - printf("offset %d nextOffset %d numberFields %d\n", - offset,nextOffset,numberFields); - ScalarConstPtr scalar = dynamic_cast(field); - if(scalar!=field) { - fprintf(stderr,"ERROR field!=scalar field %p scalar %p\n",field,scalar); - } - buffer.clear(); - buffer += "value "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - pvScalar->message(String("this is a test message"),infoMessage); - bool isEqual = pvScalar==pvScalar; - printf("expect true isEqual %s\n",(isEqual ? "true" : "false")); - delete pvValue; -} - -int main(int argc,char *argv[]) -{ - pfieldCreate = getFieldCreate(); - pvDataCreate = getPVDataCreate(); - testBoolean(); - testByte(); - testShort(); - testInt(); - testLong(); - testFloat(); - testDouble(); - testString(); - return(0); -} - diff --git a/pvDataApp/test/testPVScalarArray.cpp b/pvDataApp/test/testPVScalarArray.cpp deleted file mode 100644 index 2477736..0000000 --- a/pvDataApp/test/testPVScalarArray.cpp +++ /dev/null @@ -1,272 +0,0 @@ -/* testPVArray.cpp */ -/* Author: Marty Kraimer Date: 2010.09 */ - -#include -#include -#include -#include -#include - -#include "requester.h" -#include "pvIntrospect.h" -#include "pvData.h" -#include "standardField.h" -#include "standardPVField.h" - -using namespace epics::pvData; - -static FieldCreate * pfieldCreate = 0; -static PVDataCreate *pvDataCreate = 0; -static String buffer(""); - -void testBooleanArray() { - printf("\ntestBooleanArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvBoolean); - PVBooleanArray *pvValue = (PVBooleanArray *)pvScalarArray; - int length = 5; - bool *value = new bool[length]; - for(int i=0; iput(0,length,value,0); - BooleanArrayData data = BooleanArrayData(); - pvValue->get(0,length,&data); - bool * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%s,%s) ", - ((value[i]==true) ? "true" : "false"), - ((getValue[i]==true) ? "true" : "false")); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} -void testByteArray() { - printf("\ntestByteArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvByte); - PVByteArray *pvValue = (PVByteArray *)pvScalarArray; - int length = 5; - int8 *value = new int8[length]; - for(int i=0; iput(0,length,value,0); - ByteArrayData data = ByteArrayData(); - pvValue->get(0,length,&data); - int8 * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%d,%d) ",(int)value[i],(int)getValue[i]); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} -void testShortArray() { - printf("\ntestShortArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvShort); - PVShortArray *pvValue = (PVShortArray *)pvScalarArray; - int length = 5; - int16 *value = new int16[length]; - for(int i=0; iput(0,length,value,0); - ShortArrayData data = ShortArrayData(); - pvValue->get(0,length,&data); - int16 * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%d,%d) ",(int)value[i],(int)getValue[i]); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} -void testIntArray() { - printf("\ntestIntArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvInt); - PVIntArray *pvValue = (PVIntArray *)pvScalarArray; - int length = 5; - int32 *value = new int32[length]; - for(int i=0; iput(0,length,value,0); - IntArrayData data = IntArrayData(); - pvValue->get(0,length,&data); - int32 * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%d,%d) ",value[i],getValue[i]); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} - -void testLongArray() { - printf("\ntestLongArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvLong); - PVLongArray *pvValue = (PVLongArray *)pvScalarArray; - int length = 5; - int64 *value = new int64[length]; - for(int i=0; iput(0,length,value,0); - LongArrayData data = LongArrayData(); - pvValue->get(0,length,&data); - int64 * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%ld,%ld) ",(long int)value[i],(long int)getValue[i]); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} - -void testFloatArray() { - printf("\ntestFloatArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvFloat); - PVFloatArray *pvValue = (PVFloatArray *)pvScalarArray; - int length = 5; - float *value = new float[length]; - for(int i=0; iput(0,length,value,0); - FloatArrayData data = FloatArrayData(); - pvValue->get(0,length,&data); - float * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%f,%f) ",value[i],getValue[i]); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} - -void testDoubleArray() { - printf("\ntestDoubleArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvDouble); - PVDoubleArray *pvValue = (PVDoubleArray *)pvScalarArray; - int length = 5; - double *value = new double[length]; - for(int i=0; iput(0,length,value,0); - DoubleArrayData data = DoubleArrayData(); - pvValue->get(0,length,&data); - double * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%f,%f) ",value[i],getValue[i]); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} - -void testStringArray() { - printf("\ntestStringArray\n"); - PVScalarArray *pvScalarArray = - getStandardPVField()->scalarArrayValue(0,pvString); - PVStringArray *pvValue = (PVStringArray *)pvScalarArray; - int length = 5; - String *value = new String[length]; - for(int i=0; iput(0,length,value,0); - StringArrayData data = StringArrayData(); - pvValue->get(0,length,&data); - String * getValue = data.data; - printf("(orig,get):"); - for(int i=0; i< length; i++) { - printf("(%s,%s) ",value[i].c_str(),getValue[i].c_str()); - } - printf("\n"); - FieldConstPtr field = pvValue->getField(); - buffer.clear(); - field->toString(&buffer); - printf("%s\n",buffer.c_str()); - buffer.clear(); - buffer += "pv "; - pvValue->toString(&buffer); - printf("%s\n",buffer.c_str()); - delete pvValue; - delete[] value; -} - -int main(int argc,char *argv[]) -{ - pfieldCreate = getFieldCreate(); - pvDataCreate = getPVDataCreate(); - testBooleanArray(); - testByteArray(); - testShortArray(); - testIntArray(); - testLongArray(); - testFloatArray(); - testDoubleArray(); - testStringArray(); - printf("main returning\n"); - return(0); -} - diff --git a/pvDataApp/test/testSimpleStructure.cpp b/pvDataApp/test/testSimpleStructure.cpp deleted file mode 100644 index 4b731d7..0000000 --- a/pvDataApp/test/testSimpleStructure.cpp +++ /dev/null @@ -1,75 +0,0 @@ -/* testSimpleStructure.cpp */ -/* Author: Marty Kraimer Date: 2010.09 */ - -#include -#include -#include -#include -#include - -#include "requester.h" -#include "pvIntrospect.h" -#include "pvData.h" -#include "standardField.h" - -using namespace epics::pvData; - -static FieldCreate * pfieldCreate = 0; -static PVDataCreate *pvDataCreate = 0; -static String buffer(""); - - -void testSimpleStructure() { - printf("\ntestSimpleStructure\n"); - String secondsPastEpoch("secondsPastEpoch"); - String nanoSeconds("nanoSeconds"); - String timeStamp("timeStamp"); - String severity("severity"); - String message("message"); - String alarm("alarm"); - String value("value"); - String top("top"); - - ScalarConstPtr pseconds = pfieldCreate->createScalar( - secondsPastEpoch,pvLong); - ScalarConstPtr pnano = pfieldCreate->createScalar( - nanoSeconds,pvInt); - FieldConstPtrArray fields = new FieldConstPtr[2]; - fields[0] = pseconds; - fields[1] = pnano; - StructureConstPtr ptimeStamp = pfieldCreate->createStructure( - timeStamp,2,fields); - ScalarConstPtr pseverity = pfieldCreate->createScalar( - severity,pvInt); - ScalarConstPtr pmessage = pfieldCreate->createScalar( - message,pvString); - fields = new FieldConstPtr[2]; - fields[0] = pseverity; - fields[1] = pmessage; - StructureConstPtr palarm = pfieldCreate->createStructure( - alarm,2,fields); - ScalarConstPtr pvalue = pfieldCreate->createScalar( - value,pvDouble); - fields = new FieldConstPtr[3]; - fields[0] = ptimeStamp; - fields[1] = palarm; - fields[2] = pvalue; - StructureConstPtr ptop = pfieldCreate->createStructure( - top,3,fields); -buffer.clear(); -ptop->toString(&buffer); -printf("%s\n",buffer.c_str()); - PVStructure *pvStructure = pvDataCreate->createPVStructure( 0, ptop); - buffer.clear(); - pvStructure->toString(&buffer); - printf("%s\n",buffer.c_str()); -} - -int main(int argc,char *argv[]) -{ - pfieldCreate = getFieldCreate(); - pvDataCreate = getPVDataCreate(); - testSimpleStructure(); - return(0); -} - diff --git a/test/testAll.pl b/test/testAll.pl index 81d4f9d..2978579 100755 --- a/test/testAll.pl +++ b/test/testAll.pl @@ -1,5 +1,7 @@ eval 'exec perl -S $0 ${1+"$@"}' # -*- Mode: perl -*- if $running_under_some_shell; # testIntTypes.pl $EPICS_HOST_ARCH = "linux-x86"; -system ("./testIntTypes.pl"); +system ("./testPVType.pl"); system ("./testIntrospect.pl"); +system ("./testPVData.pl"); +system ("./testPVStructureArray.pl"); diff --git a/test/testIntTypes.pl b/test/testIntTypes.pl deleted file mode 100755 index ebfefdc..0000000 --- a/test/testIntTypes.pl +++ /dev/null @@ -1,12 +0,0 @@ -eval 'exec perl -S $0 ${1+"$@"}' # -*- Mode: perl -*- - if $running_under_some_shell; # testIntTypes.pl -$EPICS_HOST_ARCH = "linux-x86"; -system ("rm testIntTypes"); -system ("rm testIntTypesDiff"); -system ("../bin/${EPICS_HOST_ARCH}/testIntTypes testIntTypes"); -system ("diff testIntTypes testIntTypesGold >> testIntTypesDiff"); -if(-z "testIntTypesDiff") { - print "testIntTypes OK\n"; -} else { - print "testIntTypes Failed\n"; -} diff --git a/test/testPVData b/test/testPVData new file mode 100644 index 0000000..68f74c8 --- /dev/null +++ b/test/testPVData @@ -0,0 +1,285 @@ + +testScalar +boolean boolean true +byte byte 10 +short short 10 +int int 10 +long long 10 +float float 10 +double double 10 +string string 10 +structure boolean + boolean value true + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure valueAlarm + boolean active false + int falseSeverity 0 + int trueSeverity 0 + int changeStateSeverity 0 +structure byte + byte value 127 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + byte lowAlarmLimit 1 + byte lowWarningLimit 0 + byte highWarningLimit 0 + byte highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + byte hystersis 0 +structure short + short value 32767 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + short lowAlarmLimit 1 + short lowWarningLimit 0 + short highWarningLimit 0 + short highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + short hystersis 0 +structure int + int value -2147483648 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + int lowAlarmLimit 1 + int lowWarningLimit 0 + int highWarningLimit 0 + int highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + int hystersis 0 +structure long + long value -9223372032559808513 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + long lowAlarmLimit 1 + long lowWarningLimit 0 + long highWarningLimit 0 + long highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + long hystersis 0 +structure float + float value 1.123e+08 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + float lowAlarmLimit 1 + float lowWarningLimit 0 + float highWarningLimit 0 + float highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + float hystersis 0 +structure double + double value 1.123e+35 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + double lowAlarmLimit 1 + double lowWarningLimit 0 + double highWarningLimit 0 + double highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + double hystersis 0 +structure string + string value this is a string + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + +testScalarArray +structure boolean + booleanArray value [true,false,true] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure byte + byteArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure short + shortArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure int + intArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure long + longArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure float + floatArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure double + doubleArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure string + stringArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +Field: totalConstruct 388 totalDestruct 295 totalReferenceCount 93 +PVField: totalConstruct 279 totalDestruct 279 diff --git a/test/testPVData.pl b/test/testPVData.pl new file mode 100755 index 0000000..264862a --- /dev/null +++ b/test/testPVData.pl @@ -0,0 +1,12 @@ +eval 'exec perl -S $0 ${1+"$@"}' # -*- Mode: perl -*- + if $running_under_some_shell; # testPVData.pl +$EPICS_HOST_ARCH = "linux-x86"; +system ("rm testPVData"); +system ("rm testPVDataDiff"); +system ("../bin/${EPICS_HOST_ARCH}/testPVData testPVData"); +system ("diff testPVData testPVDataGold >> testPVDataDiff"); +if(-z "testPVDataDiff") { + print "testPVData OK\n"; +} else { + print "testPVData Failed\n"; +} diff --git a/test/testIntTypesDiff b/test/testPVDataDiff similarity index 100% rename from test/testIntTypesDiff rename to test/testPVDataDiff diff --git a/test/testPVDataGold b/test/testPVDataGold new file mode 100644 index 0000000..68f74c8 --- /dev/null +++ b/test/testPVDataGold @@ -0,0 +1,285 @@ + +testScalar +boolean boolean true +byte byte 10 +short short 10 +int int 10 +long long 10 +float float 10 +double double 10 +string string 10 +structure boolean + boolean value true + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure valueAlarm + boolean active false + int falseSeverity 0 + int trueSeverity 0 + int changeStateSeverity 0 +structure byte + byte value 127 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + byte lowAlarmLimit 1 + byte lowWarningLimit 0 + byte highWarningLimit 0 + byte highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + byte hystersis 0 +structure short + short value 32767 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + short lowAlarmLimit 1 + short lowWarningLimit 0 + short highWarningLimit 0 + short highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + short hystersis 0 +structure int + int value -2147483648 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + int lowAlarmLimit 1 + int lowWarningLimit 0 + int highWarningLimit 0 + int highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + int hystersis 0 +structure long + long value -9223372032559808513 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + long lowAlarmLimit 1 + long lowWarningLimit 0 + long highWarningLimit 0 + long highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + long hystersis 0 +structure float + float value 1.123e+08 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + float lowAlarmLimit 1 + float lowWarningLimit 0 + float highWarningLimit 0 + float highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + float hystersis 0 +structure double + double value 1.123e+35 + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + structure display + string description this is a description + string format f10.2 + string units SomeUnits + structure limit + double low 0 + double high 10 + structure control + structure limit + double low 1 + double high 9 + double minStep 0 + structure valueAlarm + boolean active true + double lowAlarmLimit 1 + double lowWarningLimit 0 + double highWarningLimit 0 + double highAlarmLimit 9 + int lowAlarmSeverity 2 + int lowWarningSeverity 0 + int highWarningSeverity 0 + int highAlarmSeverity 2 + double hystersis 0 +structure string + string value this is a string + structure alarm + int severity 2 + string message messageForAlarm + structure timeStamp + long secondsPastEpoch 123456789 + int nanoSeconds 1000000 + +testScalarArray +structure boolean + booleanArray value [true,false,true] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure byte + byteArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure short + shortArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure int + intArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure long + longArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure float + floatArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure double + doubleArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +structure string + stringArray value [0,1,2] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +Field: totalConstruct 388 totalDestruct 295 totalReferenceCount 93 +PVField: totalConstruct 279 totalDestruct 279 diff --git a/test/testPVStructureArray b/test/testPVStructureArray new file mode 100644 index 0000000..722c326 --- /dev/null +++ b/test/testPVStructureArray @@ -0,0 +1,60 @@ +structure powerSupply + structureArray value + [ + structure powerSupply + structure voltage + double value 0 + structure alarm + int severity 0 + string message + structure power + double value 0 + structure alarm + int severity 0 + string message + structure current + double value 0 + structure alarm + int severity 0 + string message , + structure powerSupply + structure voltage + double value 0 + structure alarm + int severity 0 + string message + structure power + double value 0 + structure alarm + int severity 0 + string message + structure current + double value 0 + structure alarm + int severity 0 + string message , + structure powerSupply + structure voltage + double value 0 + structure alarm + int severity 0 + string message + structure power + double value 0 + structure alarm + int severity 0 + string message + structure current + double value 0 + structure alarm + int severity 0 + string message + ] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +Field: totalConstruct 153 totalDestruct 60 totalReferenceCount 93 +PVField: totalConstruct 56 totalDestruct 56 diff --git a/test/testPVStructureArray.pl b/test/testPVStructureArray.pl new file mode 100755 index 0000000..deb3a56 --- /dev/null +++ b/test/testPVStructureArray.pl @@ -0,0 +1,12 @@ +eval 'exec perl -S $0 ${1+"$@"}' # -*- Mode: perl -*- + if $running_under_some_shell; # testPVStructureArray.pl +$EPICS_HOST_ARCH = "linux-x86"; +system ("rm testPVStructureArray"); +system ("rm testPVStructureArrayDiff"); +system ("../bin/${EPICS_HOST_ARCH}/testPVStructureArray testPVStructureArray"); +system ("diff testPVStructureArray testPVStructureArrayGold >> testPVStructureArrayDiff"); +if(-z "testPVStructureArrayDiff") { + print "testPVStructureArray OK\n"; +} else { + print "testPVStructureArray Failed\n"; +} diff --git a/test/testPVStructureArrayDiff b/test/testPVStructureArrayDiff new file mode 100644 index 0000000..e69de29 diff --git a/test/testPVStructureArrayGold b/test/testPVStructureArrayGold new file mode 100644 index 0000000..722c326 --- /dev/null +++ b/test/testPVStructureArrayGold @@ -0,0 +1,60 @@ +structure powerSupply + structureArray value + [ + structure powerSupply + structure voltage + double value 0 + structure alarm + int severity 0 + string message + structure power + double value 0 + structure alarm + int severity 0 + string message + structure current + double value 0 + structure alarm + int severity 0 + string message , + structure powerSupply + structure voltage + double value 0 + structure alarm + int severity 0 + string message + structure power + double value 0 + structure alarm + int severity 0 + string message + structure current + double value 0 + structure alarm + int severity 0 + string message , + structure powerSupply + structure voltage + double value 0 + structure alarm + int severity 0 + string message + structure power + double value 0 + structure alarm + int severity 0 + string message + structure current + double value 0 + structure alarm + int severity 0 + string message + ] + structure alarm + int severity 0 + string message + structure timeStamp + long secondsPastEpoch 0 + int nanoSeconds 0 +Field: totalConstruct 153 totalDestruct 60 totalReferenceCount 93 +PVField: totalConstruct 56 totalDestruct 56 diff --git a/test/testIntTypes b/test/testPVType similarity index 100% rename from test/testIntTypes rename to test/testPVType diff --git a/test/testPVType.pl b/test/testPVType.pl new file mode 100755 index 0000000..32a3eb1 --- /dev/null +++ b/test/testPVType.pl @@ -0,0 +1,12 @@ +eval 'exec perl -S $0 ${1+"$@"}' # -*- Mode: perl -*- + if $running_under_some_shell; # testPVType.pl +$EPICS_HOST_ARCH = "linux-x86"; +system ("rm testPVType"); +system ("rm testPVTypeDiff"); +system ("../bin/${EPICS_HOST_ARCH}/testPVType testPVType"); +system ("diff testPVType testPVTypeGold >> testPVTypeDiff"); +if(-z "testPVTypeDiff") { + print "testPVType OK\n"; +} else { + print "testPVType Failed\n"; +} diff --git a/test/testPVTypeDiff b/test/testPVTypeDiff new file mode 100644 index 0000000..e69de29 diff --git a/test/testIntTypesGold b/test/testPVTypeGold similarity index 100% rename from test/testIntTypesGold rename to test/testPVTypeGold