/* channelLocal.cpp */
/**
 * Copyright - See the COPYRIGHT that is included with this distribution.
 * EPICS pvData is distributed subject to a Software License Agreement found
 * in file LICENSE that is included with this distribution.
 */
/**
 * @author Marty Kraimer
 * @date 2013.04
 */

#include <sstream>

#include <epicsThread.h>
#include <pv/timeStamp.h>
#include <pv/convert.h>
#include <pv/pvSubArrayCopy.h>

#define epicsExportSharedSymbols

#include <pv/channelProviderLocal.h>

using namespace epics::pvData;
using namespace epics::pvAccess;
using std::tr1::static_pointer_cast;
using std::tr1::dynamic_pointer_cast;
using std::cout;
using std::endl;
using std::string;

namespace epics { namespace pvDatabase { 

static ConvertPtr convert = getConvert();
static StructureConstPtr nullStructure;
static PVStructurePtr nullPVStructure;
static BitSetPtr nullBitSet;
static Status channelDestroyedStatus(
    Status::STATUSTYPE_ERROR,
    "was destroyed"
);
static Status illegalOffsetStatus(
    Status::STATUSTYPE_ERROR,
    "count must be >0"
);
static Status illegalCountStatus(
    Status::STATUSTYPE_ERROR,
    "count must be >0"
);
static Status illegalStrideStatus(
    Status::STATUSTYPE_ERROR,
    "stride must be >0"
);


class ChannelProcessLocal;
typedef std::tr1::shared_ptr<ChannelProcessLocal> ChannelProcessLocalPtr;
class ChannelGetLocal;
typedef std::tr1::shared_ptr<ChannelGetLocal> ChannelGetLocalPtr;
class ChannelPutLocal;
typedef std::tr1::shared_ptr<ChannelPutLocal> ChannelPutLocalPtr;
class ChannelPutGetLocal;
typedef std::tr1::shared_ptr<ChannelPutGetLocal> ChannelPutGetLocalPtr;
class ChannelMonitorLocal;
typedef std::tr1::shared_ptr<ChannelMonitorLocal> ChannelMonitorLocalPtr;
class ChannelRPCLocal;
typedef std::tr1::shared_ptr<ChannelRPCLocal> ChannelRPCLocalPtr;
class ChannelArrayLocal;
typedef std::tr1::shared_ptr<ChannelArrayLocal> ChannelArrayLocalPtr;

static bool getProcess(PVStructurePtr pvRequest,bool processDefault)
{
    PVFieldPtr pvField = pvRequest->getSubField("record._options.process");
    if(!pvField || pvField->getField()->getType()!=scalar) {
        return processDefault;
    }
    ScalarConstPtr scalar = static_pointer_cast<const Scalar>(
        pvField->getField());
    if(scalar->getScalarType()==pvString) {
        PVStringPtr pvString = static_pointer_cast<PVString>(pvField);
        return  pvString->get().compare("true")==0 ? true : false;
    } else if(scalar->getScalarType()==pvBoolean) {
        PVBooleanPtr pvBoolean = static_pointer_cast<PVBoolean>(pvField);
       	return pvBoolean.get();
    }
    return processDefault;
}

class ChannelProcessLocal :
    public ChannelProcess,
    public std::tr1::enable_shared_from_this<ChannelProcessLocal>
{
public:
    POINTER_DEFINITIONS(ChannelProcessLocal);
    virtual ~ChannelProcessLocal()
    {
         if(pvRecord->getTraceLevel()>0)
         {
             cout << "~ChannelProcessLocal() " << endl;
         }
    }
    static ChannelProcessLocalPtr create(
        ChannelLocalPtr const &channelLocal,
        ChannelProcessRequester::shared_pointer const & channelProcessRequester,
        PVStructurePtr const & pvRequest,
        PVRecordPtr const &pvRecord);
    virtual void process();
    virtual void destroy();
    virtual std::tr1::shared_ptr<Channel> getChannel()
        {return channelLocal;}
    virtual void cancel(){}
    virtual void lastRequest() {}
    virtual void lock() {mutex.lock();}
    virtual void unlock() {mutex.unlock();}
private:
    shared_pointer getPtrSelf()
    {
        return shared_from_this();
    }
    ChannelProcessLocal(
        ChannelLocalPtr const &channelLocal,
        ChannelProcessRequester::shared_pointer const & channelProcessRequester,
        PVRecordPtr const &pvRecord,
        int nProcess)
    : 
      isDestroyed(false),
      channelLocal(channelLocal),
      channelProcessRequester(channelProcessRequester),
      pvRecord(pvRecord),
      nProcess(nProcess)
    {
    }
    bool isDestroyed;
    ChannelLocalPtr channelLocal;
    ChannelProcessRequester::shared_pointer channelProcessRequester;
    PVRecordPtr pvRecord;
    Mutex mutex;
    int nProcess;
};

ChannelProcessLocalPtr ChannelProcessLocal::create(
    ChannelLocalPtr const &channelLocal,
    ChannelProcessRequester::shared_pointer const & channelProcessRequester,
    PVStructurePtr const & pvRequest,
    PVRecordPtr const &pvRecord)
{
    PVFieldPtr pvField;
    PVStructurePtr pvOptions;
    int nProcess = 1;
    if(pvRequest) pvField = pvRequest->getSubField("record._options");
    if(pvField) {
        pvOptions = static_pointer_cast<PVStructure>(pvField);
        pvField = pvOptions->getSubField("nProcess");
        if(pvField) {
            PVStringPtr pvString = pvOptions->getStringField("nProcess");
            if(pvString) {
                int size;
                std::stringstream ss;
                ss << pvString->get();
                ss >> size;
                nProcess = size;
            }
        }
    }
    ChannelProcessLocalPtr process(new ChannelProcessLocal(
        channelLocal,
        channelProcessRequester,
        pvRecord,
        nProcess));
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelProcessLocal::create";
        cout << " recordName " << pvRecord->getRecordName() << endl;
    }
    channelProcessRequester->channelProcessConnect(Status::Ok, process);
    return process;
}


void ChannelProcessLocal::destroy()
{
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelProcessLocal::destroy";
        cout << " destroyed " << isDestroyed << endl;
    }
    {
        Lock xx(mutex);
        if(isDestroyed) return;
        isDestroyed = true;
    }
    channelLocal.reset();
}


void ChannelProcessLocal::process()
{
    if(isDestroyed) {
         channelProcessRequester->processDone(channelDestroyedStatus,getPtrSelf());
         return;
    } 
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelProcessLocal::process";
        cout << " nProcess " << nProcess << endl;
    }
    for(int i=0; i< nProcess; i++) {
        pvRecord->lock();
        try {
            pvRecord->beginGroupPut();
            pvRecord->process();
            pvRecord->endGroupPut();
        } catch(...) {
            pvRecord->unlock();
            throw;
        }
        pvRecord->unlock();
    }
    channelProcessRequester->processDone(Status::Ok,getPtrSelf());
}

class ChannelGetLocal :
    public ChannelGet,
    public std::tr1::enable_shared_from_this<ChannelGetLocal>
{
public:
    POINTER_DEFINITIONS(ChannelGetLocal);
    virtual ~ChannelGetLocal()
    {
         if(pvRecord->getTraceLevel()>0)
        {
           cout << "~ChannelGetLocal()" << endl;
         }
    }
    static ChannelGetLocalPtr create(
        ChannelLocalPtr const &channelLocal,
        ChannelGetRequester::shared_pointer const & channelGetRequester,
        PVStructurePtr const & pvRequest,
        PVRecordPtr const &pvRecord);
    virtual void get();
    virtual void destroy();
    virtual std::tr1::shared_ptr<Channel> getChannel()
        {return channelLocal;}
    virtual void cancel(){}
    virtual void lastRequest() {}
    virtual void lock() {mutex.lock();}
    virtual void unlock() {mutex.unlock();}
private:
    shared_pointer getPtrSelf()
    {
        return shared_from_this();
    }
    ChannelGetLocal(
        bool callProcess,
        ChannelLocalPtr const &channelLocal,
        ChannelGetRequester::shared_pointer const & channelGetRequester,
        PVCopyPtr const &pvCopy,
        PVStructurePtr const&pvStructure,
        BitSetPtr const & bitSet,
        PVRecordPtr const &pvRecord)
    : 
      firstTime(true),
      isDestroyed(false),
      callProcess(callProcess),
      channelLocal(channelLocal),
      channelGetRequester(channelGetRequester),
      pvCopy(pvCopy),
      pvStructure(pvStructure),
      bitSet(bitSet),
      pvRecord(pvRecord)
    {
    }
    bool firstTime;
    bool isDestroyed;
    bool callProcess;
    ChannelLocalPtr channelLocal;
    ChannelGetRequester::shared_pointer channelGetRequester;
    PVCopyPtr pvCopy;
    PVStructurePtr pvStructure;
    BitSetPtr bitSet;
    PVRecordPtr pvRecord;
    Mutex mutex;
};

ChannelGetLocalPtr ChannelGetLocal::create(
    ChannelLocalPtr const &channelLocal,
    ChannelGetRequester::shared_pointer const & channelGetRequester,
    PVStructurePtr const & pvRequest,
    PVRecordPtr const &pvRecord)
{
    PVCopyPtr pvCopy = PVCopy::create(
        pvRecord->getPVRecordStructure()->getPVStructure(),
        pvRequest,
        "");
    if(!pvCopy) {
        Status status(
            Status::STATUSTYPE_ERROR,
            "invalid pvRequest");
        ChannelGet::shared_pointer channelGet;
        channelGetRequester->channelGetConnect(
            status,
            channelGet,
            nullStructure);
        ChannelGetLocalPtr localGet;
        return localGet;
    }
    PVStructurePtr pvStructure = pvCopy->createPVStructure();
    BitSetPtr   bitSet(new BitSet(pvStructure->getNumberFields()));
    ChannelGetLocalPtr get(new ChannelGetLocal(
        getProcess(pvRequest,false),
        channelLocal,
        channelGetRequester,
        pvCopy,
        pvStructure,
        bitSet,
        pvRecord));
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelGetLocal::create";
        cout << " recordName " << pvRecord->getRecordName() << endl;
    }
    channelGetRequester->channelGetConnect(
        Status::Ok,get,pvStructure->getStructure());
    return get;
}


void ChannelGetLocal::destroy()
{
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelGetLocal::destroy";
        cout << " destroyed " << isDestroyed << endl;
    }
    {
        Lock xx(mutex);
        if(isDestroyed) return;
        isDestroyed = true;
    }
    channelLocal.reset();
}

void ChannelGetLocal::get()
{
    if(isDestroyed) {
         channelGetRequester->getDone(
             channelDestroyedStatus,getPtrSelf(),nullPVStructure,nullBitSet);
         return;
    } 
    bitSet->clear();
    pvRecord->lock();
    try {
        if(callProcess) {
            pvRecord->beginGroupPut();
            pvRecord->process();
            pvRecord->endGroupPut();
        }
        pvCopy->updateCopySetBitSet(pvStructure, bitSet);
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    if(firstTime) {
        bitSet->clear();
        bitSet->set(0);
        firstTime = false;
    } 
    channelGetRequester->getDone(
        Status::Ok,
        getPtrSelf(),
        pvStructure,
        bitSet);
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelGetLocal::get" << endl;
    }
}

class ChannelPutLocal :
    public ChannelPut,
    public std::tr1::enable_shared_from_this<ChannelPutLocal>
{
public:
    POINTER_DEFINITIONS(ChannelPutLocal);
    virtual ~ChannelPutLocal()
    {
         if(pvRecord->getTraceLevel()>0)
         {
            cout << "~ChannelPutLocal()" << endl;
        }
    }
    static ChannelPutLocalPtr create(
        ChannelLocalPtr const &channelLocal,
        ChannelPutRequester::shared_pointer const & channelPutRequester,
        PVStructurePtr const & pvRequest,
        PVRecordPtr const &pvRecord);
    virtual void put(PVStructurePtr const &pvStructure,BitSetPtr const &bitSet);
    virtual void get();
    virtual void destroy();
    virtual std::tr1::shared_ptr<Channel> getChannel()
        {return channelLocal;}
    virtual void cancel(){}
    virtual void lastRequest() {}
    virtual void lock() {mutex.lock();}
    virtual void unlock() {mutex.unlock();}
private:
    shared_pointer getPtrSelf()
    {
        return shared_from_this();
    }
    ChannelPutLocal(
        bool callProcess,
        ChannelLocalPtr const &channelLocal,
        ChannelPutRequester::shared_pointer const & channelPutRequester,
        PVCopyPtr const &pvCopy,
        PVRecordPtr const &pvRecord)
    :
      isDestroyed(false),
      callProcess(callProcess),
      channelLocal(channelLocal),
      channelPutRequester(channelPutRequester),
      pvCopy(pvCopy),
      pvRecord(pvRecord)
    {
    }
    bool isDestroyed;
    bool callProcess;
    ChannelLocalPtr channelLocal;
    ChannelPutRequester::shared_pointer channelPutRequester;
    PVCopyPtr pvCopy;
    PVRecordPtr pvRecord;
    Mutex mutex;
};

ChannelPutLocalPtr ChannelPutLocal::create(
    ChannelLocalPtr const &channelLocal,
    ChannelPutRequester::shared_pointer const & channelPutRequester,
    PVStructurePtr const & pvRequest,
    PVRecordPtr const &pvRecord)
{
    PVCopyPtr pvCopy = PVCopy::create(
        pvRecord->getPVRecordStructure()->getPVStructure(),
        pvRequest,
        "");
    if(!pvCopy) {
        Status status(
            Status::STATUSTYPE_ERROR,
            "invalid pvRequest");
        ChannelPut::shared_pointer channelPut;
        PVStructurePtr pvStructure;
        BitSetPtr bitSet;
        channelPutRequester->channelPutConnect(
            status,
            channelPut,
            nullStructure);
        ChannelPutLocalPtr localPut;
        return localPut;
    }
    ChannelPutLocalPtr put(new ChannelPutLocal(
        getProcess(pvRequest,true),
        channelLocal,
        channelPutRequester,
        pvCopy,
        pvRecord));
    channelPutRequester->channelPutConnect(
        Status::Ok, put, pvCopy->getStructure());
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelPutLocal::create";
        cout << " recordName " << pvRecord->getRecordName() << endl;
    }
    return put;
}

void ChannelPutLocal::destroy()
{
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelPutLocal::destroy";
        cout << " destroyed " << isDestroyed << endl;
    }
    {
        Lock xx(mutex);
        if(isDestroyed) return;
        isDestroyed = true;
    }
    channelLocal.reset();
}

void ChannelPutLocal::get()
{
    if(isDestroyed) {
         channelPutRequester->getDone(
             channelDestroyedStatus,getPtrSelf(),nullPVStructure,nullBitSet);
         return;
    }
    PVStructurePtr pvStructure = pvCopy->createPVStructure();
    BitSetPtr bitSet(new BitSet(pvStructure->getNumberFields()));
    bitSet->clear();
    bitSet->set(0);
    pvRecord->lock();
    try {
        pvCopy->updateCopyFromBitSet(pvStructure, bitSet);
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    channelPutRequester->getDone(
       Status::Ok,getPtrSelf(),pvStructure,bitSet);
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelPutLocal::get" << endl;
    }
}

void ChannelPutLocal::put(
    PVStructurePtr const &pvStructure,BitSetPtr const &bitSet)
{
    if(isDestroyed) {
         channelPutRequester->putDone(channelDestroyedStatus,getPtrSelf());
         return;
    }
    pvRecord->lock();
    try {
        pvRecord->beginGroupPut();
        pvCopy->updateMaster(pvStructure, bitSet);
        if(callProcess) {
             pvRecord->process();
        }
        pvRecord->endGroupPut();
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    channelPutRequester->putDone(Status::Ok,getPtrSelf());
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelPutLocal::put" << endl;
    }
}


class ChannelPutGetLocal :
    public ChannelPutGet,
    public std::tr1::enable_shared_from_this<ChannelPutGetLocal>
{
public:
    POINTER_DEFINITIONS(ChannelPutGetLocal);
    virtual ~ChannelPutGetLocal()
    {
         if(pvRecord->getTraceLevel()>0)
         {
            cout << "~ChannelPutGetLocal()" << endl;
        }
    }
    static ChannelPutGetLocalPtr create(
        ChannelLocalPtr const &channelLocal,
        ChannelPutGetRequester::shared_pointer const & channelPutGetRequester,
        PVStructurePtr const & pvRequest,
        PVRecordPtr const &pvRecord);
    virtual void putGet(
        PVStructurePtr const &pvPutStructure,
        BitSetPtr const &putBitSet);
    virtual void getPut();
    virtual void getGet();
    virtual void destroy();
    virtual std::tr1::shared_ptr<Channel> getChannel()
        {return channelLocal;}
    virtual void cancel(){}
    virtual void lastRequest() {}
    virtual void lock() {mutex.lock();}
    virtual void unlock() {mutex.unlock();}
private:
    shared_pointer getPtrSelf()
    {
        return shared_from_this();
    }
    ChannelPutGetLocal(
        bool callProcess,
        ChannelLocalPtr const &channelLocal,
        ChannelPutGetRequester::shared_pointer const & channelPutGetRequester,
        PVCopyPtr const &pvPutCopy,
        PVCopyPtr const &pvGetCopy,
        PVStructurePtr const&pvGetStructure,
        BitSetPtr const & getBitSet,
        PVRecordPtr const &pvRecord)
    : 
      isDestroyed(false),
      callProcess(callProcess),
      channelLocal(channelLocal),
      channelPutGetRequester(channelPutGetRequester),
      pvPutCopy(pvPutCopy),
      pvGetCopy(pvGetCopy),
      pvGetStructure(pvGetStructure),
      getBitSet(getBitSet),
      pvRecord(pvRecord)
    {
    }
    bool isDestroyed;
    bool callProcess;
    ChannelLocalPtr channelLocal;
    ChannelPutGetRequester::shared_pointer channelPutGetRequester;
    PVCopyPtr pvPutCopy;
    PVCopyPtr pvGetCopy;
    PVStructurePtr pvGetStructure;
    BitSetPtr getBitSet;
    PVRecordPtr pvRecord;
    Mutex mutex;
};

ChannelPutGetLocalPtr ChannelPutGetLocal::create(
    ChannelLocalPtr const &channelLocal,
    ChannelPutGetRequester::shared_pointer const & channelPutGetRequester,
    PVStructurePtr const & pvRequest,
    PVRecordPtr const &pvRecord)
{
    PVCopyPtr pvPutCopy = PVCopy::create(
        pvRecord->getPVRecordStructure()->getPVStructure(),
        pvRequest,
        "putField");
    PVCopyPtr pvGetCopy = PVCopy::create(
        pvRecord->getPVRecordStructure()->getPVStructure(),
        pvRequest,
        "getField");
    if(!pvPutCopy || !pvGetCopy) {
        Status status(
            Status::STATUSTYPE_ERROR,
            "invalid pvRequest");
        ChannelPutGet::shared_pointer channelPutGet;
        channelPutGetRequester->channelPutGetConnect(
            status,
            channelPutGet,
            nullStructure,
            nullStructure);
        ChannelPutGetLocalPtr localPutGet;
        return localPutGet;
    }
    PVStructurePtr pvGetStructure = pvGetCopy->createPVStructure();
    BitSetPtr   getBitSet(new BitSet(pvGetStructure->getNumberFields()));
    ChannelPutGetLocalPtr putGet(new ChannelPutGetLocal(
        getProcess(pvRequest,true),
        channelLocal,
        channelPutGetRequester,
        pvPutCopy,
        pvGetCopy,
        pvGetStructure,
        getBitSet,
        pvRecord));
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelPutGetLocal::create";
        cout << " recordName " << pvRecord->getRecordName() << endl;
    }
    channelPutGetRequester->channelPutGetConnect(
        Status::Ok, putGet, pvPutCopy->getStructure(),pvGetCopy->getStructure());
    return putGet;
}


void ChannelPutGetLocal::destroy()
{
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelPutGetLocal::destroy";
        cout << " destroyed " << isDestroyed << endl;
    }
    {
        Lock xx(mutex);
        if(isDestroyed) return;
        isDestroyed = true;
    }
    channelLocal.reset();
}

void ChannelPutGetLocal::putGet(
    PVStructurePtr const &pvPutStructure,BitSetPtr const &putBitSet)
{
    if(isDestroyed) {
         channelPutGetRequester->putGetDone(
             channelDestroyedStatus,getPtrSelf(),nullPVStructure,nullBitSet);
         return;
    } 
    pvRecord->lock();
    try {
        pvRecord->beginGroupPut();
        pvPutCopy->updateMaster(pvPutStructure, putBitSet);
        if(callProcess) pvRecord->process();
        getBitSet->clear();
        pvGetCopy->updateCopySetBitSet(pvGetStructure, getBitSet);
        pvRecord->endGroupPut();
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    channelPutGetRequester->putGetDone(
        Status::Ok,getPtrSelf(),pvGetStructure,getBitSet);
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelPutGetLocal::putGet" << endl;
    }
}

void ChannelPutGetLocal::getPut()
{
    if(isDestroyed) {
         channelPutGetRequester->getPutDone(
              channelDestroyedStatus,getPtrSelf(),nullPVStructure,nullBitSet);
         return;
    } 
    PVStructurePtr pvPutStructure = pvPutCopy->createPVStructure();
    BitSetPtr putBitSet(new BitSet(pvPutStructure->getNumberFields()));
    pvRecord->lock();
    try {
        pvPutCopy->initCopy(pvPutStructure, putBitSet);
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    channelPutGetRequester->getPutDone(
        Status::Ok,getPtrSelf(),pvPutStructure,putBitSet);
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelPutGetLocal::getPut" << endl;
    }
}

void ChannelPutGetLocal::getGet()
{
    if(isDestroyed) {
         channelPutGetRequester->getGetDone(
             channelDestroyedStatus,getPtrSelf(),nullPVStructure,nullBitSet);
         return;
    } 
    getBitSet->clear();
    pvRecord->lock();
    try {
        pvGetCopy->updateCopySetBitSet(pvGetStructure, getBitSet);
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    channelPutGetRequester->getGetDone(
        Status::Ok,getPtrSelf(),pvGetStructure,getBitSet);
    if(pvRecord->getTraceLevel()>1)
    {
        cout << "ChannelPutGetLocal::getGet" << endl;
    }
}

typedef std::tr1::shared_ptr<PVArray> PVArrayPtr;

class ChannelArrayLocal :
    public ChannelArray,
    public std::tr1::enable_shared_from_this<ChannelArrayLocal>
{
public:
    POINTER_DEFINITIONS(ChannelArrayLocal);
    virtual ~ChannelArrayLocal()
    {
         if(pvRecord->getTraceLevel()>0)
         {
            cout << "~ChannelArrayLocal()" << endl;
        }
    }
    static ChannelArrayLocalPtr create(
        ChannelLocalPtr const &channelLocal,
        ChannelArrayRequester::shared_pointer const & channelArrayRequester,
        PVStructurePtr const & pvRequest,
        PVRecordPtr const &pvRecord);
    virtual void getArray(size_t offset, size_t count, size_t stride);
    virtual void putArray(
         PVArrayPtr const &putArray,
         size_t offset, size_t count, size_t stride);
    virtual void getLength();
    virtual void setLength(size_t length);
    virtual void destroy();
    virtual std::tr1::shared_ptr<Channel> getChannel()
        {return channelLocal;}
    virtual void cancel(){}
    virtual void lastRequest() {}
    virtual void lock() {mutex.lock();}
    virtual void unlock() {mutex.unlock();}
private:
    shared_pointer getPtrSelf()
    {
        return shared_from_this();
    }
    ChannelArrayLocal(
        ChannelLocalPtr const &channelLocal,
        ChannelArrayRequester::shared_pointer const & channelArrayRequester,
        PVArrayPtr const &pvArray,
        PVArrayPtr const &pvCopy,
        PVRecordPtr const &pvRecord)
    : 
      isDestroyed(false),
      channelLocal(channelLocal),
      channelArrayRequester(channelArrayRequester),
      pvArray(pvArray),
      pvCopy(pvCopy),
      pvRecord(pvRecord)
    {
    }
    bool isDestroyed;
    ChannelLocalPtr channelLocal;
    ChannelArrayRequester::shared_pointer channelArrayRequester;
    PVArrayPtr pvArray;
    PVArrayPtr pvCopy;
    PVRecordPtr pvRecord;
    Mutex mutex;
};


ChannelArrayLocalPtr ChannelArrayLocal::create(
    ChannelLocalPtr const &channelLocal,
    ChannelArrayRequester::shared_pointer const & channelArrayRequester,
    PVStructurePtr const & pvRequest,
    PVRecordPtr const &pvRecord)
{
    PVFieldPtrArray const & pvFields = pvRequest->getPVFields();
    if(pvFields.size()!=1) {
        Status status(
            Status::STATUSTYPE_ERROR,"invalid pvRequest");
        ChannelArrayLocalPtr channelArray;
        ArrayConstPtr array;
        channelArrayRequester->channelArrayConnect(status,channelArray,array);
        return channelArray;
    }
    PVFieldPtr pvField = pvFields[0];
    string fieldName("");
    while(true) {
        string name = pvField->getFieldName();
        if(fieldName.size()>0) fieldName += '.';
        fieldName += name;
        PVStructurePtr pvs = static_pointer_cast<PVStructure>(pvField);
        PVFieldPtrArray const & pvfs = pvs->getPVFields();
        if(pvfs.size()!=1) break;
        pvField = pvfs[0];
    }
    size_t indfield = fieldName.find_first_of("field.");
    if(indfield==0) {
         fieldName = fieldName.substr(6);
    }
    pvField = pvRecord->getPVRecordStructure()->getPVStructure()->getSubField(fieldName);
    if(!pvField) {
        Status status(
            Status::STATUSTYPE_ERROR,fieldName +" not found");
        ChannelArrayLocalPtr channelArray;
        ArrayConstPtr array;
        channelArrayRequester->channelArrayConnect(
            status,channelArray,array);
        return channelArray;
    }
    if(pvField->getField()->getType()!=scalarArray
    && pvField->getField()->getType()!=structureArray
    && pvField->getField()->getType()!=unionArray)
    {
        Status status(
            Status::STATUSTYPE_ERROR,fieldName +" not array");
        ChannelArrayLocalPtr channelArray;
        ArrayConstPtr array;
        channelArrayRequester->channelArrayConnect(
           status,channelArray,array);
        return channelArray;
    }
    PVArrayPtr pvArray = static_pointer_cast<PVArray>(pvField);
    PVArrayPtr pvCopy;
    if(pvField->getField()->getType()==scalarArray) {
        PVScalarArrayPtr xxx = static_pointer_cast<PVScalarArray>(pvField);
        pvCopy = getPVDataCreate()->createPVScalarArray(
            xxx->getScalarArray()->getElementType());
        ChannelArrayLocalPtr array(new ChannelArrayLocal(
            channelLocal,
            channelArrayRequester,
            pvArray,
            pvCopy,
            pvRecord));
        if(pvRecord->getTraceLevel()>0)
        {
            cout << "ChannelArrayLocal::create";
            cout << " recordName " << pvRecord->getRecordName() << endl;
        }
        channelArrayRequester->channelArrayConnect(
            Status::Ok, array, pvCopy->getArray());
        return array;
    }
    if(pvField->getField()->getType()==structureArray) {
        PVStructureArrayPtr xxx = static_pointer_cast<PVStructureArray>(pvField);
        pvCopy = getPVDataCreate()->createPVStructureArray(
            xxx->getStructureArray()->getStructure());
        ChannelArrayLocalPtr array(new ChannelArrayLocal(
            channelLocal,
            channelArrayRequester,
            pvArray,
            pvCopy,
            pvRecord));
        if(pvRecord->getTraceLevel()>0)
        {
            cout << "ChannelArrayLocal::create";
            cout << " recordName " << pvRecord->getRecordName() << endl;
        }
        channelArrayRequester->channelArrayConnect(
            Status::Ok, array, pvCopy->getArray());
        return array;
    }
    if(pvField->getField()->getType()==unionArray) {
        PVUnionArrayPtr xxx = static_pointer_cast<PVUnionArray>(pvField);
        pvCopy = getPVDataCreate()->createPVUnionArray(
            xxx->getUnionArray()->getUnion());
        ChannelArrayLocalPtr array(new ChannelArrayLocal(
            channelLocal,
            channelArrayRequester,
            pvArray,
            pvCopy,
            pvRecord));
        if(pvRecord->getTraceLevel()>0)
        {
            cout << "ChannelArrayLocal::create";
            cout << " recordName " << pvRecord->getRecordName() << endl;
        }
        channelArrayRequester->channelArrayConnect(
            Status::Ok, array, pvCopy->getArray());
        return array;
    }
    
    Status status(Status::STATUSTYPE_ERROR,
            "Logic error. Should not reach this code");
    ChannelArrayLocalPtr channelArray;
    ArrayConstPtr array;
    channelArrayRequester->channelArrayConnect(status,channelArray,array);
    return channelArray;
}


void ChannelArrayLocal::destroy()
{
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "ChannelArrayLocal::destroy";
        cout << " destroyed " << isDestroyed << endl;
    }
    {
        Lock xx(mutex);
        if(isDestroyed) return;
        isDestroyed = true;
    }
    channelLocal.reset();
}

void ChannelArrayLocal::getArray(size_t offset, size_t count, size_t stride)
{
    if(isDestroyed) {
         channelArrayRequester->getArrayDone(channelDestroyedStatus,getPtrSelf(),pvCopy);
         return;
    }
    if(pvRecord->getTraceLevel()>1)
    {
       cout << "ChannelArrayLocal::getArray" << endl;
    }
    if(offset<0) {
         channelArrayRequester->getArrayDone(illegalOffsetStatus,getPtrSelf(),pvCopy);
         return;
    }
    if(stride<0) {
         channelArrayRequester->getArrayDone(illegalStrideStatus,getPtrSelf(),pvCopy);
         return;
    }
    const char *exceptionMessage = NULL;
    pvRecord->lock();
    try {
        bool ok = false;
        while(true) {
            size_t length  = pvArray->getLength();
            if(length<=0) break;
            if(count<=0) {
                 count = (length -offset + stride -1)/stride;
                 if(count>0) ok = true;
                 break;
            }
            size_t maxcount = (length -offset + stride -1)/stride;
            if(count>maxcount) count = maxcount;
            ok = true;
            break;
        }
        if(ok) {
            pvCopy->setLength(count);
            copy(pvArray,offset,stride,pvCopy,0,1,count);
        }
    } catch(std::exception e) {
        exceptionMessage = e.what();
    }
    pvRecord->unlock();
    Status status = Status::Ok;
    if(exceptionMessage!=NULL) {
      status = Status(Status::STATUSTYPE_ERROR,exceptionMessage);
    }
    channelArrayRequester->getArrayDone(status,getPtrSelf(),pvCopy);
}

void ChannelArrayLocal::putArray(
     PVArrayPtr const & pvArray, size_t offset, size_t count, size_t stride)
{
    if(isDestroyed) {
         channelArrayRequester->putArrayDone(channelDestroyedStatus,getPtrSelf());
         return;
    }
    if(pvRecord->getTraceLevel()>1)
    {
       cout << "ChannelArrayLocal::putArray" << endl;
    }
    if(offset<0) {
         channelArrayRequester->putArrayDone(illegalOffsetStatus,getPtrSelf());
         return;
    }
    if(count<0) {
         channelArrayRequester->putArrayDone(illegalCountStatus,getPtrSelf());
         return;
    }
    if(stride<0) {
         channelArrayRequester->putArrayDone(illegalStrideStatus,getPtrSelf());
         return;
    }
    size_t newLength = offset + count*stride;
    if(newLength<pvArray->getLength()) pvArray->setLength(newLength);
    const char *exceptionMessage = NULL;
    pvRecord->lock();
    try {
        copy(pvArray,0,1,this->pvArray,offset,stride,count);
    } catch(std::exception e) {
        exceptionMessage = e.what();
    }
    pvRecord->unlock();
    Status status = Status::Ok;
    if(exceptionMessage!=NULL) {
        status = Status(Status::STATUSTYPE_ERROR,exceptionMessage);
    }
    channelArrayRequester->putArrayDone(status,getPtrSelf());
}

void ChannelArrayLocal::getLength()
{
    size_t length = 0;
    const char *exceptionMessage = NULL;
    pvRecord->lock();
    try {
        length = pvArray->getLength();
    } catch(std::exception e) {
        exceptionMessage = e.what();
    }
    pvRecord->unlock();
    Status status = Status::Ok;
    if(exceptionMessage!=NULL) {
        status = Status(Status::STATUSTYPE_ERROR,exceptionMessage);
    }
    channelArrayRequester->getLengthDone(status,getPtrSelf(),length);
}

void ChannelArrayLocal::setLength(size_t length)
{
    if(isDestroyed) {
         channelArrayRequester->setLengthDone(channelDestroyedStatus,getPtrSelf());
         return;
    }
    if(pvRecord->getTraceLevel()>1)
    {
       cout << "ChannelArrayLocal::setLength" << endl;
    }
    pvRecord->lock();
    try {
        if(length>=0) {
            if(pvArray->getLength()!=length) pvArray->setLength(length);
        }
    } catch(...) {
        pvRecord->unlock();
        throw;
    }
    pvRecord->unlock();
    channelArrayRequester->setLengthDone(Status::Ok,getPtrSelf());
}


class ChannelRPCLocal :
    public ChannelRPC
{
public:
    POINTER_DEFINITIONS(ChannelRPCLocal);
    virtual ~ChannelRPCLocal();
    static ChannelRPC::shared_pointer create(
        ChannelProviderLocalPtr const &channelProvider,
        ChannelRPC::shared_pointer const & channelRPCRequester,
        PVStructurePtr const & pvRequest,
        PVRecordPtr const &pvRecord);
    virtual void request(
        PVStructurePtr const & pvArgument,
        bool lastRequest);
};


ChannelLocal::ChannelLocal(
    ChannelProviderLocalPtr const & provider,
    ChannelRequester::shared_pointer const & requester,
    PVRecordPtr const & pvRecord)
:   provider(provider),
    requester(requester),
    pvRecord(pvRecord),
    beingDestroyed(false)
{
}

ChannelLocal::~ChannelLocal()
{
    if(pvRecord->getTraceLevel()>0)
    {
        cout << "~ChannelLocal()" << endl;
    }
}

void ChannelLocal::destroy()
{
    if(pvRecord->getTraceLevel()>0) {
         cout << "ChannelLocal::destroy() ";
         cout << "beingDestroyed " << beingDestroyed << endl;
    }
    {
        Lock xx(mutex);
        if(beingDestroyed) return;
        beingDestroyed = true;
    }
    pvRecord->removePVRecordClient(getPtrSelf());
}

void ChannelLocal::detach(PVRecordPtr const & pvRecord)
{
    if(pvRecord->getTraceLevel()>0) {
         cout << "ChannelLocal::detach() " << endl;
    }
    destroy();
}


string ChannelLocal::getRequesterName()
{
    return requester->getRequesterName();
}

void ChannelLocal::message(
        string const &message,
        MessageType messageType)
{
    requester->message(message,messageType);
}

string ChannelLocal::getRemoteAddress()
{
    return string("local");
}

Channel::ConnectionState ChannelLocal::getConnectionState()
{
    return Channel::CONNECTED;
}

string ChannelLocal::getChannelName()
{
    return pvRecord->getRecordName();
}

ChannelRequester::shared_pointer ChannelLocal::getChannelRequester()
{
    return requester;
}

bool ChannelLocal::isConnected()
{
    return true;
}

void ChannelLocal::getField(GetFieldRequester::shared_pointer const &requester,
        string const &subField)
{
    if(subField.size()<1) {
        StructureConstPtr structure =
            pvRecord->getPVRecordStructure()->getPVStructure()->getStructure();
        requester->getDone(Status::Ok,structure);
        return;
    } 
    PVFieldPtr pvField = 
        pvRecord->getPVRecordStructure()->getPVStructure()->getSubField(subField);
    if(pvField) {
        requester->getDone(Status::Ok,pvField->getField());
        return;
    }
    Status status(Status::STATUSTYPE_ERROR,
        "client asked for illegal field");
    requester->getDone(status,FieldConstPtr());
}

AccessRights ChannelLocal::getAccessRights(
        PVField::shared_pointer const &pvField)
{
    throw std::logic_error("Not Implemented");
}

ChannelProcess::shared_pointer ChannelLocal::createChannelProcess(
        ChannelProcessRequester::shared_pointer const & channelProcessRequester,
        PVStructure::shared_pointer const & pvRequest)
{
    ChannelProcessLocalPtr channelProcess =
       ChannelProcessLocal::create(
            getPtrSelf(),
            channelProcessRequester,
            pvRequest,
            pvRecord);
    return channelProcess;
}

ChannelGet::shared_pointer ChannelLocal::createChannelGet(
        ChannelGetRequester::shared_pointer const &channelGetRequester,
        PVStructure::shared_pointer const &pvRequest)
{
    ChannelGetLocalPtr channelGet =
       ChannelGetLocal::create(
            getPtrSelf(),
            channelGetRequester,
            pvRequest,
            pvRecord);
    return channelGet;
}

ChannelPut::shared_pointer ChannelLocal::createChannelPut(
        ChannelPutRequester::shared_pointer const &channelPutRequester,
        PVStructure::shared_pointer const &pvRequest)
{
    ChannelPutLocalPtr channelPut =
       ChannelPutLocal::create(
            getPtrSelf(),
            channelPutRequester,
            pvRequest,
            pvRecord);
    return channelPut;
}

ChannelPutGet::shared_pointer ChannelLocal::createChannelPutGet(
        ChannelPutGetRequester::shared_pointer const &channelPutGetRequester,
        PVStructure::shared_pointer const &pvRequest)
{
    ChannelPutGetLocalPtr channelPutGet =
       ChannelPutGetLocal::create(
            getPtrSelf(),
            channelPutGetRequester,
            pvRequest,
            pvRecord);
    return channelPutGet;
}

ChannelRPC::shared_pointer ChannelLocal::createChannelRPC(
        ChannelRPCRequester::shared_pointer const & channelRPCRequester,
        PVStructure::shared_pointer const & pvRequest)
{
    Status status(Status::STATUSTYPE_ERROR,
        "ChannelRPC not supported");
    channelRPCRequester->channelRPCConnect(status,ChannelRPC::shared_pointer());
    return ChannelRPC::shared_pointer();
}

Monitor::shared_pointer ChannelLocal::createMonitor(
        MonitorRequester::shared_pointer const &monitorRequester,
        PVStructure::shared_pointer const &pvRequest)
{
    MonitorPtr monitor = 
        getMonitorFactory()->createMonitor(
            pvRecord,
            monitorRequester,
            pvRequest);
    return monitor;
}

ChannelArray::shared_pointer ChannelLocal::createChannelArray(
        ChannelArrayRequester::shared_pointer const &channelArrayRequester,
        PVStructure::shared_pointer const &pvRequest)
{
    ChannelArrayLocalPtr channelArray =
       ChannelArrayLocal::create(
            getPtrSelf(),
            channelArrayRequester,
            pvRequest,
            pvRecord);
    return channelArray;
}

void ChannelLocal::printInfo()
{
    printInfo(std::cout);
}

void ChannelLocal::printInfo(std::ostream& out)
{
    out << "ChannelLocal provides access to a record in the local PVDatabase";
}

}}