gav_aux.cc

分布式仿真 开放源码

        return RTI_FALSE ;
    else
        return RTI_TRUE ;
}

// ----------------------------------------------------------------------------
// AttributeHandleSetImpFactory
// ----------------------------------------------------------------------------

AttributeHandleSet*
AttributeHandleSetFactory::create(ULong)
    throw (MemoryExhausted, ValueCountExceeded)
{
    return ((AttributeHandleSet *)new AttributeHandleSetImp());
}

// ----------------------------------------------------------------------------
// FederateHandleSetImp
// ----------------------------------------------------------------------------
FederateHandleSetImp::~FederateHandleSetImp()
{
    empty();
}

// ----------------------------------------------------------------------------
inline ULong
FederateHandleSetImp::size() const
{
    return list<FederateHandle>::size();
}

// ----------------------------------------------------------------------------
FederateHandle
FederateHandleSetImp::getHandle(ULong i) const
    throw (ArrayIndexOutOfBounds)
{
    list<FederateHandle>::const_iterator h ;
    ULong j ;
    for (j = 0, h = begin(); h != end(); h++, j++) {
        if (i == j)
            return (*h);
    }

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
void
FederateHandleSetImp::add(FederateHandle h)
    throw (ValueCountExceeded)
{
    push_front(h);
}

// ----------------------------------------------------------------------------
void
FederateHandleSetImp::remove(FederateHandle h)
    throw (AttributeNotDefined, ArrayIndexOutOfBounds)
{
    if (isMember(h) == RTI_TRUE)
        list<FederateHandle>::remove(h);
    else
        throw AttributeNotDefined();
}

// ----------------------------------------------------------------------------
void
FederateHandleSetImp::empty()
{
    list<FederateHandle>::clear();
}

// ----------------------------------------------------------------------------
Boolean
FederateHandleSetImp::isMember(FederateHandle h) const
{
    list<FederateHandle>::const_iterator result = find(begin(), end(), h);

    if (result == end())
        return RTI_FALSE ;
    else
        return RTI_TRUE ;
}

// ----------------------------------------------------------------------------
// FederateHandleSetFactory
// ----------------------------------------------------------------------------

FederateHandleSet*
FederateHandleSetFactory::create(ULong)
    throw (MemoryExhausted, ValueCountExceeded)
{
    return ((FederateHandleSet *) new FederateHandleSetImp());
}

// ----------------------------------------------------------------------------
// ParameterHandleValuePair
// ----------------------------------------------------------------------------

ParameterHandleValuePair::ParameterHandleValuePair(Handle handle,
                                                   const char *value,
                                                   ULong value_length)
{
    _handle = handle ;
    _valueLength = value_length ;

    _value = (char *)malloc(value_length);
    memcpy(_value, value, value_length);
}

// ----------------------------------------------------------------------------
ParameterHandleValuePair::~ParameterHandleValuePair()
{
    delete _value ;
}

// ----------------------------------------------------------------------------
// ParameterHandleValuePairSetImp
// ----------------------------------------------------------------------------
ParameterHandleValuePairSetImp::ParameterHandleValuePairSetImp(ULong)
{
    _order = RECEIVE ;
    _transport = RELIABLE ;
}

ParameterHandleValuePairSetImp::~ParameterHandleValuePairSetImp()
{
    empty();
}

// ----------------------------------------------------------------------------
inline ULong
ParameterHandleValuePairSetImp::size() const
{
    return list<ParameterHandleValuePair *>::size();
}

// ----------------------------------------------------------------------------
Handle
ParameterHandleValuePairSetImp::getHandle(ULong i) const
    throw (ArrayIndexOutOfBounds)
{
    list<ParameterHandleValuePair *>::const_iterator j = begin();
    for (ULong k = 0 ; j != end(); j++, k++) {
        if (i == k)
            return (*j)->_handle ;
    }

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
ULong
ParameterHandleValuePairSetImp::getValueLength(ULong i) const
    throw (ArrayIndexOutOfBounds)
{
    list<ParameterHandleValuePair *>::const_iterator j = begin();
    for (ULong k = 0 ; j != end(); j++, k++) {
        if (i == k)
            return (*j)->_valueLength ;
    }

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
void
ParameterHandleValuePairSetImp::getValue(ULong i,
                                         char *buff,
                                         ULong& value_length) const
    throw (ArrayIndexOutOfBounds)
{
    list<ParameterHandleValuePair *>::const_iterator j = begin();
    for (ULong k = 0 ; j != end(); j++, k++) {
        if (i == k) {
            value_length = (*j)->_valueLength ;
            memcpy(buff, (*j)->_value, (*j)->_valueLength);
            return ;
        }
    }

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
char *
ParameterHandleValuePairSetImp::getValuePointer(ULong i,
                                                ULong& value_length) const
    throw (ArrayIndexOutOfBounds)
{
    list<ParameterHandleValuePair *>::const_iterator j = begin();
    for (ULong k = 0 ; j != end(); j++, k++) {
        if (i == k) {
            value_length = (*j)->_valueLength ;
            return (*j)->_value ;
        }
    }

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
inline TransportType
ParameterHandleValuePairSetImp::getTransportType() const
    throw (InvalidHandleValuePairSetContext)
{
    return _transport ;
}

// ----------------------------------------------------------------------------
inline OrderType
ParameterHandleValuePairSetImp::getOrderType() const
    throw (InvalidHandleValuePairSetContext)
{
    return _order ;
}

// ----------------------------------------------------------------------------
Region *
ParameterHandleValuePairSetImp::getRegion() const
    throw (InvalidHandleValuePairSetContext,
           UnimplementedService)//CERTI
{
    throw UnimplementedService();
}

// ----------------------------------------------------------------------------
void
ParameterHandleValuePairSetImp::add(Handle h,
                                    const char *buff,
                                    ULong value_length)
    throw (ValueLengthExceeded, ValueCountExceeded)
{
    ParameterHandleValuePair *phvp ;
    phvp = new ParameterHandleValuePair(h, buff, value_length);

    push_front(phvp);
}

// ----------------------------------------------------------------------------
void
ParameterHandleValuePairSetImp::remove(Handle h)
    throw (ArrayIndexOutOfBounds)
{
    list<ParameterHandleValuePair *>::iterator j ;
    for (j = begin(); j != end(); j++) {
        if ((*j)->_handle == h) {
            delete (*j);
            erase(j);
            return ;
        }
    }

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
void
ParameterHandleValuePairSetImp::moveFrom(const ParameterHandleValuePairSet&,
                                         ULong&)
    throw (ValueCountExceeded, ArrayIndexOutOfBounds,
           UnimplementedService)//CERTI
{
    throw UnimplementedService();
}

// ----------------------------------------------------------------------------
void
ParameterHandleValuePairSetImp::empty()
{
    while (!list<ParameterHandleValuePair *>::empty()) {
        delete front();
        pop_front();
    }
}

// ----------------------------------------------------------------------------
ULong
ParameterHandleValuePairSetImp::start() const
{
    //not implemented
    return 0 ;
}

// ----------------------------------------------------------------------------
ULong
ParameterHandleValuePairSetImp::valid(ULong) const
{
    //not implemented
    return 0 ;
}

// ----------------------------------------------------------------------------
ULong
ParameterHandleValuePairSetImp::next(ULong) const
{
    //not implemented
    return 0 ;
}

// ----------------------------------------------------------------------------
// ParameterSetFactory
// ----------------------------------------------------------------------------

ParameterHandleValuePairSet*
ParameterSetFactory::create(ULong size)
    throw (MemoryExhausted, ValueCountExceeded,
           HandleValuePairMaximumExceeded)
{
    ParameterHandleValuePairSetImp *phvps ;
    phvps = new ParameterHandleValuePairSetImp(size);

    phvps->_order = RECEIVE ;
    phvps->_transport = RELIABLE ;
    return (ParameterHandleValuePairSet *) phvps ;
}

} // namespace certi

// $Id: GAV_aux.cc,v 3.11 2004/03/04 20:19:05 breholee Exp $