gav_aux.cc

分布式仿真 开放源码

// ----------------------------------------------------------------------------
// CERTI - HLA RunTime Infrastructure
// Copyright (C) 2002, 2003  ONERA
//
// This file is part of CERTI-libCERTI
//
// CERTI-libCERTI is free software ; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation ; either version 2 of
// the License, or (at your option) any later version.
//
// CERTI-libCERTI is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY ; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program ; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// $Id: GAV_aux.cc,v 3.11 2004/03/04 20:19:05 breholee Exp $
// ----------------------------------------------------------------------------

#include <config.h>
#include "GAV.hh"

#include "PrettyDebug.hh"
#include "converter.hh"

#include <algorithm>
#include <assert.h>

using std::list ;

// ----------------------------------------------------------------------------
// AttributeHandleValuePair
// ----------------------------------------------------------------------------

namespace certi {

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

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

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

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

// ----------------------------------------------------------------------------
ULong
AttributeHandleValuePairSetImp::size() const
{
    return list<AttributeHandleValuePair *>::size();
}

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

    throw ArrayIndexOutOfBounds();
}

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

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
void
AttributeHandleValuePairSetImp::getValue(ULong i,
                                         char *buff,
                                         ULong& value_length) const
    throw (ArrayIndexOutOfBounds)
{
    list<AttributeHandleValuePair *>::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 *
AttributeHandleValuePairSetImp::getValuePointer(ULong i,
                                                ULong& value_length) const
    throw (ArrayIndexOutOfBounds)
{
    list<AttributeHandleValuePair *>::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
AttributeHandleValuePairSetImp::getTransportType(ULong) const
    throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext)
{
    return _transport ;
}

// ----------------------------------------------------------------------------
inline OrderType
AttributeHandleValuePairSetImp::getOrderType(ULong) const
    throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext)
{
    return _order ;
}

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

// ----------------------------------------------------------------------------
void
AttributeHandleValuePairSetImp::add(Handle h,
                                    const char *buff,
                                    ULong value_length)
    throw (ValueLengthExceeded, ValueCountExceeded)
{
    AttributeHandleValuePair *ahvp ;
    ahvp = new AttributeHandleValuePair(h, buff, value_length);

    push_front(ahvp);
}

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

    throw ArrayIndexOutOfBounds();
}

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

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

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

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

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

// ----------------------------------------------------------------------------
// AttributeSetFactory
// ----------------------------------------------------------------------------

AttributeHandleValuePairSet*
AttributeSetFactory::create(ULong)
    throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
{
    AttributeHandleValuePairSetImp *ahvps ;
    ahvps = new AttributeHandleValuePairSetImp ;
    ahvps->_order = RECEIVE ;
    ahvps->_transport = RELIABLE ;
    return (AttributeHandleValuePairSet *) ahvps ;
}

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

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

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

    throw ArrayIndexOutOfBounds();
}

// ----------------------------------------------------------------------------
void
AttributeHandleSetImp::add(AttributeHandle h)
    throw (ArrayIndexOutOfBounds, AttributeNotDefined)
{
    push_front(h);
}

// ----------------------------------------------------------------------------
void
AttributeHandleSetImp::remove(AttributeHandle h)
    throw (AttributeNotDefined)// not guaranteed safe while iterating
{
    if (isMember(h) == RTI_TRUE)
        list<AttributeHandle>::remove(h);
    else
        throw AttributeNotDefined();
}

// ----------------------------------------------------------------------------
void
AttributeHandleSetImp::empty()
{
    list<AttributeHandle>::clear();
}

// ----------------------------------------------------------------------------
inline Boolean
AttributeHandleSetImp::isEmpty() const
{
    return ((list<AttributeHandle>::empty()) ? RTI_TRUE : RTI_FALSE);
}

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

    if (result == end())