下面是NetEngine头文件中最主要的一个，也是最大的一个。
/*
* Copyright (C) 1993 by Environmental Systems Research Institute Inc.
* All Rights Reserved.
*
* N O T I C E
*
* THIS MATERIAL IS CONSIDERED A TRADE SECRET BY ESRI.
* UNAUTHORIZED ACCESS IS PROHIBITED.
*
* %W% %G% %U%
*/
#ifndef _NETLIB_H_
#define _NETLIB_H_
/* Category: Library API - netlib */
/***********************************************************************
Overview
***********************************************************************/
/*
* This header file contains basic data type definition and APIs for
* the core Network Engine library netlib.
*
* The Network Engine provides the capability to define, store, traverse,
* and analyze Networks. The Network Engine is very versatile and has
* been designed to facilitate advanced Network analysis. In addition
* to having several Network analytic solvers, the Engine also provides
* efficient access to the Network through the browser and the forward star
* cursor.
*
* Refer to the object model in thedo
c for the overall design of the
* Network Engine.
*/
/***********************************************************************
Public Data Types
***********************************************************************/
/*
* The Network Engine library consists of many data types. The data types
* implement core Network Engine components. Every component has public
* and private attributes. Abstract data types implement the private
* attributes of a component whereas, the public attributes are
* implemented by simple typedefs. The following naming convention is
* used throughout the Network Engine.
*
* The data types that implement public attributes of a component are
* named ComponentAttRec, and ComponentAttPtr. ComponentAttRec is a
* typedef struct ComponentAttPtr is a pointer to ComponentAttRec.
* Abstract data types implementing private attributes of a component are
* named _ComponentRec, and ComponentPtr. _ComponentRec is the abstract
* data type that implements the component's private attribute record
* ComponentPtr is a pointer to the private component. The UNDERSCORE
* is a convention used to indicate an abstract data type.
*
* A component is fully defined by all its attributes. In some cases,
* all the attributes of a component are public/private. In such cases,
* there would be only one data type/pointer pair for that component.
*
* A Network is a collection of elements where an element could be a
* junction, or an edge, or a turn. Each element can belong to one (and
* only one) layer. While creating a Network, the client chooses the
* name of the Network and a character description to be stored along
* with the Network.
*
* The Network is an abstract data type.
*/
#ifdef _SARRAY
#ifndef _WIN32
#include "_WIN32 preprocessor directive not specified
#endif
#endif
typedef struct _NetworkRec *NetworkPtr;
/*
* Name and description of the Network are its public attributes.
*
+ Name A string containing the name of the layer.
+ Description A string that contains the client's description of the
* Network.
*
*/
typedef struct {
BStr Name;
BStr Description;
} NetworkAttRec, *NetworkAttPtr;
/*
* A Network has an access mode as defined by the enum below
+ NE_READWRITE The client has read/write access to the Network
+ NE_READONLY The client has read only access to the Network
*/
typedef enum {
NE_READWRITE, NE_READONLY
} AccessModeEnum, *AccessModePtr;
/*
* A Network could be indexed on one of several modes.
+ NE_SIMPLE A simple indexing scheme that assumes the following:
* 1) The UserIDs are non-negative (>=0).
* 2) The UserIDs are unique within a layer.
* 3) The network is undirected (every edge is added twice
* one for each direction)
* NOTE: The result networks written by the Netviewdo
es not
* satisfy these assumptions.do
not use any of the Query by ID APIs.
+ NE_FASTINDEX An indexing scheme used primarily in internal use.
*/
typedef enum {
NE_SIMPLE = 0, NE_FASTINDEX
} IndexTypeEnum, *IndexTypePtr;
/*
* A Network can have many layers.
*
* The layer is an abstract data type.
*/
typedef struct _LayerRec *LayerPtr;
/*
* A layer within a Network is defined by its name, source, and
* keysource. The layer definition is stored with the Network.
*
+ Name A string containing the name of the layer.
+ Source A string describing the source of the layer.
* Example, cover.aat, map.shp etc.
+ KeySource A string describing the source of the client's key
* stored with the elements. For example, cover-id.
+ LayerID The client specified ID of the layer.
*/
typedef struct {
BStr Name;
BStr Source;
BStr KeySource;
Int32 LayerID;
} LayerAttRec, *LayerAttPtr;
/*
* The Network can have many weights. The client can store multiple weights
* associated with each element. The client also has the option of describing
* the weight that needs to be reported when traversing the Network.
*
* The weight is an abstract data type.
*/
typedef struct _WeightRec *WeightPtr;
/*
* Weights are associated with a Network and are defined by their name,
* source, and description.
*
+ Name A string describing the name of the weight.
* Examples, AmTravelTime, FlowCapacity etc.
+ Source A string that contains the source of the weight. Could be
* the name of the item in the client's database that
* contained the values. For example, FT_TRAV_TIME, LENGTH.
+ Description A string that contains the client's description about
* of weight.
+ WeightID The client specified ID of the weight.
*/
typedef struct {
BStr Name;
BStr Source;
BStr Description;
Int32 WeightID;
} WeightAttRec, *WeightAttPtr;
/*
* A Network is composed of many elements. Each element has a handle
* which is a unique unsiged integer which can be thought of as an
* internal id for the element. Handles are generated by the Network
* Engine.
*
+ Handle An unsigned integer representing the internal id of the
* element.
*/
typedef struct {
UInt32 Handle;
} HandleAttRec, *HandleAttPtr;
/*
* PercentValue is the datatype for the numeric values that specify a
* percentage along an edge. The legal range of values for PercentValue
* are between 0.0 and 100.0. However, it is not enforced by the Network
* Engine.
*/
typedef Float PercentValue;
/*
* Each element has a client defined ID which is stored along with the
* element. The Engine also provides APIs to search by the client's IDs.
* The client's ID is stored in the IDAttRec structure.
*
+ LayerKey The key value of the layer that the element belongs to.
* The key values are generated by the Network Engine when
* the layer is added.
+ UserID This is the client's ID of the element. For example, it
* could be the cover-id.
+ IsPartial A BoolEnum that specifies if the element is partially
* active or not. Every element has an active range, i.e.,
* the portion of the element that is active. For example,
* an NE_EDGE that is partially active (say) with a
* FromRange of 0% and a ToRange of 50%, implies that only
* half of the NE_EDGE can be traversed. The client can
* model road-block, road-work etc. accurately.
* Partial traversals such as starting from a house that is
* 80% along the NE_EDGE can also be modeled.
* The Network Engine extends the generality of ActiveRange
* to all ElementTypes.
+ FromRange A PercentValue that indicates the range from which the
* element is active.
+ ToRange A PercentValue that indicates the range up to which the
* element is active.
*/
typedef struct {
UInt32 LayerKey;
Int32 UserID;
BoolEnum IsPartial;
PercentValue FromRange;
PercentValue ToRange;
} IDAttRec, *IDAttPtr;
/*
* WeightValue is the datatype for the numeric values of weights for the
* elements.
*/
typedef Float WeightValue, *WeightValuePtr;
/*
* Each element has a weight value defined by the following structure.
*
+ WeightKey Weights are associated with a network. Since a network can have
* multiple weights, each element has a vector of weight
* values associated with it.
*
+ WeightValue The actual numeric value that stores the weight.
* Currently, it is a single precision floating point value.
*
*/
typedef struct {
UInt32 WeightKey;
WeightValue WeightValue;
} WeightValueAttRec, *WeightValueAttPtr;
/*
* There are three types of elements as defined by the enum below.
+ NE_JUNCTION A junction type that models vertices of a graph.
+ NE_EDGE An edge type that models edges of a graph.
+ NE_TURN A turn type that models additional weights/restrictions
* of traversing from one edge to another through a
* junction.
*/
typedef enum {
NE_JUNCTION = 1, NE_EDGE, NE_TURN
} ElementTypeEnum, *ElementTypePtr;
/*
* Every element is uniquely defined by its from, to, and at handle
* attributes which is encapsulated in the following structure.
+ From The from element handle. If type = NE_EDGE, then
From
* should correspond to the junction element that is the from
* junction of the edge. If type = NE_TURN, then
From
* should correspond to an edge element i.e., the edge from
* which the turn is made.
+ To The to element handle. If type = NE_EDGE, then
To
* should correspond to the NE_JUNCTION element that is the
* to junction of the edge. If type = NE_TURN, then
To
* should correspond to an NE_EDGE element i.e., the edge
* into which the turn is made.
+ At A NE_JUNCTION element handle defined only when
* type = NE_TURN. At corresponds to the junction at which
* the turn is made.
*/
typedef struct {
HandleAttRec From;
HandleAttRec To;
HandleAttRec At;
} ElementDefRec, *ElementDefPtr;
/*
* The ElementAttRec is useful in adding and deleting elements. It
* facilitates having a single API to add junctions, edges, and turns.
*
+ Type Specified by the client to be one of junction, edge, or
* turn. Based upon the type that has been set, the
* algorithm to add will ignore some of the other members
* of the struct. For example if type = NE_JUNCTION, fromP,
* toP, and atP will be ignored.
+ HAtt A handle to the element that has just been added. This
* will be returned by the Engine
+ IDRec The record containing the ID of the element as defined
* above.
* This field is populated by the client. The Network Engine
* provides APIs to access elements by their IDs.
+ ElDef Element defintion record.
+ WeightValsP An array containing the weights that have been added to the
* network. The array should be indexed by the WeightKey. Weight
* keys are assigned by the Engine and are sequential starting
* from 0.
*/
typedef struct {
ElementTypeEnum Type;
HandleAttRec HAtt;
IDAttRec IDRec;
ElementDefRec ElDef;
WeightValuePtr WeightValsP;
} ElementAttRec, *ElementAttPtr;
/*
* A Network is likely to change with time and the Engine provides
* several editing capabilities. All of them require that the network
* is in the edit mode i.e., the client has permission to edit the
* network. The abstract data type NetEditPtr implements this. The
* Engine wil allow edits only when the proper NetEditPtr is provided.
* This allows the client to set up the proper editing environment.
*/
typedef struct _NetEditRec *NetEditPtr;
/*
* NetBrowsePtr is an abstract data type that implements the ability to
* scan or browse through the network. The client can perform several
* operations like Seek to an element and start listing Previous
* and Next elements in sequence using this.
*/
typedef struct _NetBrowseRec *NetBrowsePtr;
/*
* Flags are markers or "bookmarks" that can be placed anywhere on the
* Network i.e., along an edge, turn, or on a junction. The client can
* use flags to mark locations along the Network that have some special
* significance. For example, the location of warehouses, hotels, tourist
* attractions could be marked as flags.
*
* There are several types of flags that the Network Engine recognizes as
* defined by the enum below:
*
+ NE_CUSTOM This is a generic flag type that has no specific significance
* as far as the Engine algorithms are concerned. The client can
* use this to store flags thatdo
not fall into any of the
* other supported types. Along with the ClientPtr the client
* can store data to support their custom solver.
+ NE_STOP Used by the path and tour solvers. A stop flag has some
* special attributes that can be used to specify stop_impedance,
* transfer, time windows etc.
+ NE_CENTER Used by the allocation solvers. A center flag has some special
* attributes that can be used to specify supply, max_impedance
* etc.
*/
typedef enum {
NE_CUSTOM, NE_STOP, NE_CENTER
} FlagTypeEnum;
/*
* A flag's public attributes can be used by the client to define flags
* of the above mentioned types.
*
+ Description The client's description of the flag. Will also be used
* in reporting directions for a path.
+ Type The flag type specified by the client. The special types
* of flags such as the NE_BARRIER, NE_STOP etc., will be
* useful in composing Netviews a discussion of which
* follows shortly.
+ HAtt The element handle on which the flag is defined.
+ Position Percentage along the element's length that marks the
* location of the flag. This value is ignored if the
* ElementP corresponds to a junction. However, when the
* flag is placed along an edge, this value defines the
* exact location of the flag.
+ AltHAtt The alternate element's handle on which the flag is defined.
* A note is in order for the requirement of an alternate element
* attribute.
* The Network Engine manages directed networks. The client
* would model an undirected network by adding two directed
* edges to the Network Engine for each edge of the
* undirected network. In such a situation, it might be
* important to maintain correspondence information between
* the two edges. For instance, a stop in the middle of an
* undirected edge is significant because a route can visit
* and leave the stop from either direction. The Network
* Engine Solvers employ algorithms that make use the
* AltElementP when set. Note that as far as the Network
* Engine is concerned, the alternate element could be
* anything. The client can devise an application where the
* stops that a route has to visit are grouped in pairs and
* given as flags with alternate elements and it suffices
* to visit one of the two elements.
+ AltPosition Percentage along the alternate element's length that
* marks the location of the flag. This value is ignored if
* the AltElementP corresponds to a junction.
*
*/
typedef struct {
BStr Description;
FlagTypeEnum Type;
HandleAttRec HAtt;
PercentValue Position;
HandleAttRec AltHAtt;
PercentValue AltPosition;
} FlagAttRec, *FlagAttPtr;
/*
* Flags define additional attributes based on the flag type. To allow
* flags to be treated generically, an abstract data type is defined.
*/
typedef struct _FlagRec *FlagPtr;
typedef enum {
NE_FIND, NE_NEXT
} NE_ActionEnum;
/*
* Netview is probably the most important data type for Network traversal
* algorithms. A Network can be thought of as a database for which
* Netview is the query definition. Using a Netview the client can
* (i) identify the weight(s) to be used by the traversal algorithm
* (ii) set up barriers that mark elements through which traversal is
* not permitted (freeway closed due to
* accident/flooding/mudslide/earthquake/fire etc.);
* (iii) set up parameters for the type of traversal algorithm (shortest
* path, TSP, etc.);
and finally (iv) perform a Solve operation.
* In most cases, the result of a Solve is a new, client specified
* Network. If the client is not interested in having a result Network,
* for eg., say the client needs the length of the shortest path rather
* than the path itself, they have the option of specifying a NULL
* Network and just have the result as a queriable attribute of the
* Netview.
*
*/
typedef struct _NetviewRec *NetviewPtr;
/*
* There are several types of Netviews that can be defined by the client.
+ NE_CUSTOMVIEW This is a generic Netview that the client can use to
* incorporate their custom solvers.
+ NE_PATHVIEW Can be used in shortest path and TSP computations.
* The client has additional flexibility to specify the
* parameters (such as stops, transfers, precedence,
* time windows etc.) while composing a NE_PATHVIEW.
+ NE_HIPATHVIEW This is the hierarchical version of the NE_PATHVIEW.
+ NE_ALLOCATEVIEW To be used in allocate computations. The client
* can set the Centers from/to which the allocation
* is to be performed. The solver can be controlled by
* setting MaxRange, MaxSupply attributes on the Centers.
+ NE_ODMATRIXVIEW Can be used in ODMatrix and Path Closest computations.
* The client can set a list of Origins (which are Centers)
* and a list of Destinations (which are also Centers).
* The solver can be controlled by setting MaxRange, MaxK
* etc., on the Origins. The Destination MaxRange, MaxK values
* are ignored.
+ NE_HIODMATRIXVIEW This is the hierarchical version of the NE_ODMATRIXVIEW.
*/
typedef enum {
NE_CUSTOMVIEW, NE_PATHVIEW, NE_HIPATHVIEW, NE_ALLOCATEVIEW, NE_ODMATRIXVIEW, NE_HIODMATRIXVIEW
} NetviewType;
typedef struct _FStarCursorRec *FStarCursorPtr;
/*
* A Solve operation on Netviews can be thought of as macro-queries on
* the Network (such as finding the shortest path). The Network Engine
* also supports some micro or atomic queries using cursors.
* A FStarCursor can be used to perform basic forward star queries by
* specifying the junction and the edge that was traversed to reach that
* junction. Memory is allocated for the forward star cursor by the
* Network Engine. Forward star queries are performed on a Netview.
*
+ AtJunctionP Junction (handle) for which the forward star is
* required.
+ FromEdgeP Pointer to the edge traversed to reach the
* junction. This plays a major role in modeling
* turns. These are the only two attributes that are
* specified by the client. The Network Engine fills
* in the rest.
+ AtJunctionWeight The WeightValue weights at the AtJunction.
+ NumReturned An integer that represents the number of adjacent
* junctions/edges returned by the query. This
* defines the dimension of the arrays returned by
* the query.
+ ToJunctionsPP An array of pointers to the handles of the to
* junctions.
+ ToEdgesPP An array of pointers to the handles of the to
* edges.
+ ToEdgeWeightsP An array of weights of the to edges.
+ ToTurnsPP An array that specifies if a turn element was
* encountered.
* This array is also of dimension NumReturned and
* has NULL values when there is no turn encountered
* while traversing from FromEdgeP through
* AtJunctionP to ToEdgesPP.
+ ToTurnWeightsP An array of turn weights associated with the turns.
* A zero WeightValue is returned for a NULL turn.
*/
typedef struct {
NetviewPtr NvP;
FStarCursorPtr FsP;
HandleAttPtr AtJunctionP;
HandleAttPtr FromEdgeP;
WeightValue AtJunctionWeight;
UInt32 NumReturned;
HandleAttPtr *ToJunctionsPP;
HandleAttPtr *ToEdgesPP;
WeightValuePtr ToEdgeWeightsP;
HandleAttPtr *ToTurnsPP;
WeightValuePtr ToTurnWeightsP;
} FStarCursorAttRec, *FStarCursorAttPtr;
/*
* In addition to the primary weight information, the client might need
* another weight, to accumulate auxiliary information during traversal.
* SecFStarCursor allows that through a set of APIs.
+ SecAtJunctionWeight The secondary weight at the AtJunction.
+ SecToEdgeWeightsP An array of secondary weights of the to edges.
+ SecToTurnWeightsP An array of secondary turn weights associated with the
+ turns. A zero WeightValue is returned for a NULL turn.
*/
typedef struct {
WeightValue SecAtJunctionWeight;
WeightValuePtr SecToEdgeWeightsP;
WeightValuePtr SecToTurnWeightsP;
} SecFStarCursorAttRec, *SecFStarCursorAttPtr;
/* Whereever appropriate, the APIs report on status and error. The
* following error types are defined
+ NE_STAT_OK Successful.
+ NE_STAT_NO_FILE File not found or file could not be opened
* with the necessary permissions.
+ NE_STAT_INCOMPATIBLE_VERSION File is a version that could not be read.
+ NE_STAT_UNABLE_TO_READ Unable to read the file.
+ NE_STAT_UNABLE_TO_WRITE Unable to write to the file.
+ NE_STAT_NO_MEMORY Unable to allocate memory.
+ NE_STAT_INVALID_INPUT Invalid input arguments.
+ NE_STAT_IMPROPER_ENV The environment is not proper for the
* operation attempted. The Start or the Stop
* operation needs to be performed first.
+ NE_STAT_INTERRUPT The current operation has been interrupted.
* This can only bedo
ne in solvers through
* registered call back function and NE_GetStatus.
+ NE_STAT_TIMEOUT If the library has timed out.
*/
typedef enum {
NE_STAT_OK = 0,
NE_STAT_NO_FILE,
NE_STAT_INCOMPATIBLE_VERSION,
NE_STAT_UNABLE_TO_READ,
NE_STAT_UNABLE_TO_WRITE,
NE_STAT_NO_MEMORY,
NE_STAT_NO_ACCESS,
NE_STAT_INVALID_INPUT,
NE_STAT_IMPROPER_ENV,
NE_STAT_INTERRUPT,
NE_STAT_TIMEOUT
} NE_ErrorStatEnum;
/***********************************************************************
Public APIs
***********************************************************************/
/*
* Recall that a Network has many components. Several types of
* operations can be performed on the components through the APIs. The
* APIs are named using a simple convention of
* OperationComponent[Qualifier]. The qualifier is optional and used
* when necessary. The operations can be grouped together on the basis
* of similarities in functionality.
*
* Create/Delete This refers to persistent component (such as the
* Network itself) which involves a physical entity
* such as a disk file etc.
* Open/Close This applies only to persistent components that can
* be opened and closed.
* Make/Dispose A Make operation results in memory allocation by
* the Network Engine and a Dispose operation SHOULD
* be used with every Make to free the memory.
* Add/Drop This refers to components of the Network such as
* layer, element etc., that can be added and if
* necessary dropped.
* These components are also persistent by being a
* part of the Network and they are destroyed if the
* Network is deleted.
* Get/Set A Get is used to return the value of an attribute,
* typically from an abstract data type whereas a Set
* is used to set the value of the attribute.
* Query A Query operation is similar to a Get in that
* both serve the function of describing an attribute
* (or a set of attributes). The major difference is
* that in a Query a data type is an output argument
* while in a Get it is the return value.
* Start/Stop Used to indicate the begin
ning(end) of an
* environment that allows some specialized
* operations which can be performed only under a
* particular environment. For example, a Network
* can be updated only in an update environment which
* is set by StartUpdateNetwork.
* Is An Is operation returns a BoolEnum about the state.
*
+ Void NE_InitNetworkEngine(Void);
* Initialize the network engine.
*
+ Void NE_ExitNetworkEngine(Void);
* Exit from the network engine.
*
+ NetworkPtr NE_CreateNetwork(NetworkAttPtr);
* Takes in the public attribute record for the Network and creates a
* Network. This results in a directory whose name is part of the
* Network attribute record. The Network remains until deleted. A NULL
* pointer is returned if the Network could not be created. Otherwise a
* Network is created and opened with read/write access. It needs to be closed.
*
+ BoolEnum NE_ResetNetwork(NetworkPtr);
* Resets the specified network. A reset totally removes all the elements,
* layers, weights, etc. Issuing a reset is equivalent todo
ing a
* NE_CreateNetwork. Reset returns BOOL_TRUE upon successful completion.
* You cannot reset a Network that is either opened with read only access or
* currently being updated
*
+ Void NE_DeleteNetwork(BStr);
* Deletes the specified Network. If the networkdo
es not exist, then
* it is a no-op.
*
+ NetworkPtr NE_OpenNetwork(BStr, AccessModeEnum);
* Opens the Network specified by the fileName and access mode and returns
* the pointer to the Network.
*
+ Void NE_CloseNetwork(NetworkPtr);
* Closes a Network opened using the Open or Create operation. The
* Enginedo
es not enforce strict conditions here. For example, it
* is the client's responsibility to make sure that the network is
* not being edited etc.
*
+ Void NE_CloseAndDeleteNetwork(NetworkPtr);
* Closes and deletes the network.
*
+ BoolEnum NE_QueryNetworkAttributes(NetworkPtr, NetworkAttPtr);
* Queries the Network attribute record.
*
+ BoolEnum NE_IsNetwork(BStr);
*do
es the name correspond to a network?
*
+ BoolEnum NE_IsNetworkWritable(NetworkPtr);
* Has the Network been opened with read/write access?
*
+ Void NE_OpenNetworkFiles(NetworkPtr);
* Open the network files closed by the NE_CloseNetworkFiles API.
*
+ Void NE_CloseNetworkFiles(NetworkPtr);
* Closes the files opened when the network was opened. Thisdo
es not close
* the network itself and the NetworkPtr memory is not released. The client
* should use this in situations where the number of file handles are small
* and the clientdo
es not want to incur the overhead of opening a network
* every time. This will be a no-op if the network is being edited currently.
*
+ BoolEnum NE_IsNetworkFilesOpen(NetworkPtr);
* Checks whether network files are open.
*
+ UInt32 NE_GetNumElements(NetworkPtr, ElementTypeEnum);
* Returns the number of elements of a given type in the Network.
*
+ BoolEnum NE_QueryVersion(NetworkPtr, UInt32Ptr, UInt32Ptr);
* Queries the version and mod of the network. For example, Version 1.12
* is version 1 mod 12.
*
+ IndexTypeEnum NE_GetIndexType(NetworkPtr);
* Returns the index type of the network.
*
+ Void NE_SetIndexType(NetworkPtr, IndexTypeEnum);
* Sets the index type of a network. This works only on writable networks
* that are empty, and currently not being updated.
*
+ NetBrowsePtr NE_StartElementList(NetworkPtr, ElementTypeEnum);
* Starts element perusal of elements of specified type. Every element
* of a specified type can be queried sequentially.
*
+ BoolEnum NE_QueryNextElement(NetBrowsePtr, IDAttPtr, HandleAttPtr);
* Query the next element of specified type in the Network for both ID
* and handle. Returns BOOL_TRUE as long as there is an element still
* to be queried. When all elements have been queried a BOOL_FALSE is
* returned.
*
+ BoolEnum NE_QueryPrevElement(NetBrowsePtr, IDAttPtr, HandleAttPtr);
* Query the previous element of specified type in the Network for both
* ID and handle. Returns BOOL_TRUE as long as there is an element
* still to be queried. When all elements have been queried a BOOL_FALSE
* is returned.
*
+ Void NE_SeekFirstElement(NetBrowsePtr);
* Seek the first element of the specified type set by the perusal
* environment using NE_StartElementList. A NE_QueryPrevElement will
* return a BOOL_FALSE and NE_QueryNextElement will query the first
* element.
*
+ Void NE_SeekLastElement(NetBrowsePtr);
* Seeks the last element of the specified type set by the perusal
* environment using NE_StartElementList. A NE_QueryNextElement will
* return a BOOL_FALSE and NE_QueryPrevElement will query the last
* element.
*
+ BoolEnum NE_SeekThisElement(NetBrowsePtr, HandleAttPtr);
* Seeks for the element specified by the HandleAtt. NE_QueryNextElement
* will return the sought element. Returns a BOOL_FALSE on failure.
*
+ Void NE_StopElementList(NetBrowsePtr);
* Stops the element perusal.
*
+ NetEditPtr NE_StartUpdateNetwork(NetworkPtr);
* Indicates that the network is to be updated or edited. The Engine
* sets up the network for update, checks permissions etc., and returns
* a NetEditPtr that should be used while updating.
*
+ Void NE_StopUpdateNetwork(NetEditPtr);
* Notice indicating that the updates on the Network aredo
ne.
*
+ BoolEnum NE_IsUpdateNetwork(NetworkPtr);
* Indicates whether the Network is being updated or not.
*
+ LayerPtr NE_AddLayer(NetEditPtr, LayerAttPtr);
* Adds the specified layer to the existing Network and returns the
* LayerKey. The LayerKey should be used when adding elements. LayerKeys
* are sequential and start from 0.
*
+ UInt32 NE_GetNumLayers(NetworkPtr);
* Gets the number of layers.
*
+ LayerPtr NE_GetLayerByName(NetworkPtr, BStr);
* Gets the layer corresponding to the name.
*
+ LayerPtr NE_GetLayerByID(NetworkPtr, Int32);
* Gets the layer corresponding to the LayerID.
*
+ LayerPtr NE_GetLayerByKey(NetworkPtr, UInt32);
* Gets the layer corresponding to the LayerKey.
*
+ BoolEnum NE_QueryLayerAttributes(LayerPtr, LayerAttPtr);
* Queries the layer's attributes.
*
+ UInt32 NE_GetLayerKey(LayerPtr);
* Gets the LayerKey.
*
+ WeightPtr NE_AddWeight(NetEditPtr, WeightAttPtr);
* Adds the specified weight to the specified layer and returns the
* WeightKey. WeightKeys are sequential and start from 0. When adding an
* element the client should pass in an array of WeightValues. Each
* entry in the WeightValue corresponds to the weight whose key is the
* index on the array. If elements already exist in the network their weights
* default to zero.
*
+ UInt32 NE_GetNumWeights(NetworkPtr);
* Gets the number of weights.
*
+ WeightPtr NE_GetWeightByName(NetworkPtr, BStr);
* Gets the weight corresponding to the name.
*
+ WeightPtr NE_GetWeightIByName(NetworkPtr, BStr);
* Gets the weight corresponding to the namedo
ing a case insensitive
* comparison.
*
+ WeightPtr NE_GetWeightByID(NetworkPtr, Int32);
* Gets the weight corresponding to the WeightID.
*
+ WeightPtr NE_GetWeightByKey(NetworkPtr, UInt32);
* Gets the weight corresponding to the WeightKey.
*
+ BoolEnum NE_QueryWeightAttributes(WeightPtr, WeightAttPtr);
* Queries the weight's attributes.
*
+ UInt32 NE_GetWeightKey(WeightPtr);
* Gets the WeightKey.
*
+ BoolEnum NE_QueryElementByID(NetworkPtr, ElementTypeEnum, IDAttPtr,
* HandleAttPtr);
* Query the element handle given its ID.
*
+ BoolEnum NE_QueryElementID(NetworkPtr, HandleAttPtr, IDAttPtr);
* Query the id of an element given its handle.
*
+ BoolEnum NE_QueryElementDef(NetworkPtr, HandleAttPtr, ElementTypePtr,
* ElementDefPtr);
* Query the element defintion. Given a network and a handle, the element
* definition is queried. The element type is also returned.
*
+ BoolEnum NE_QueryElementWeightVal(NetworkPtr, HandleAttPtr, WeightPtr,
WeightValuePtr);
* Query an individual weightvalue of the given element.
*
+ BoolEnum NE_QueryElementWeightVals(NetworkPtr, HandleAttPtr, WeightValuePtr);
* Query the element's WeightValues. Given a network and a handle the
* element's WeightValues are queried into an array indexed by WeightKey.
*
+ Void NE_AddElement(NetEditPtr, ElementAttPtr);
* Add the given element using the specified element record.
*
+ Void NE_AddElementByID(NetEditPtr, ElementAttPtr, IDAttPtr, IDAttPtr,
* IDAttPtr);
* Add the given element when the input is given in IDs of the from, to
* and at elements.
*
+ Void NE_SetElementRange(NetEditPtr, HandleAttPtr, PercentValue, PercentValue);
* Set the range of the given element. NOTE: THIS IS SUPPORTED FOR EDGES
* ONLY.
*
+ Void NE_SetElementWeightVals(NetEditPtr, HandleAttPtr, WeightValuePtr);
* Set the weight values of the element specified by the handle. Useful when
* the weight values need to be changed.
*
+ FlagPtr NE_MakeFlag(FlagAttPtr);
* Makes a flag pointing to the given element, position.
*
+ BoolEnum NE_QueryFlagAtt(FlagPtr,FlagAttPtr);
* Query the public flag attribute record that corresponds to the
* abstract flag data type.
*
+ Void NE_DisposeFlag(FlagPtr);
* Disposes the flag and frees the memory.
*
+ Void NE_SetFlagClientPtr(FlagPtr, Void *);
* Set the client ptr of the flag. This lets the client store data with
* the flag.
*
+ Void *NE_GetFlagClientPtr(FlagPtr);
* Get the client ptr of the flag.
*
+ Void NE_SetStopDemand(FlagPtr, Float);
* Sets the demand for the stop.
*
+ Void NE_SetStopImpedance(FlagPtr, Float);
* Sets the impedance for the stop.
*
+ Void NE_SetStopPrecedence(FlagPtr, Float);
* Sets the precedence for the stop.
*
+ Void NE_SetStopCumulDemand(FlagPtr, Float);
* Sets the cumulative demand for the stop.
*
+ Void NE_SetStopCumulImpedance(FlagPtr, Float);
* Sets the cumulative impedance for the stop.
*
+ Void NE_SetStopOutOrder(FlagPtr, Int32);
* Sets the output order for the stop. This reports the results of a tour.
*
+ Float NE_GetStopDemand(FlagPtr);
* Gets the demand for the stop.
*
+ Float NE_GetStopImpedance(FlagPtr);
* Gets the impedance for the stop.
*
+ Float NE_GetStopPrecedence(FlagPtr);
* Gets the precedence for the stop.
*
+ Float NE_GetStopCumulDemand(FlagPtr);
* Gets the cumulative demand for the stop.
*
+ Float NE_GetStopCumulImpedance(FlagPtr);
* Gets the cumulative impedance for the stop.
*
+ Int32 NE_GetStopOutOrder(FlagPtr);
* Gets the output order for the stop.
*
+ Void NE_SetCenterSupply(FlagPtr flagP, Float val);
* Set the NE_CENTER flag's supply. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Void NE_SetCenterRange(FlagPtr flagP, Float val);
* Set the NE_CENTER flag's range. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Void NE_SetCenterTotalDemand(FlagPtr flagP, Float val);
* Set the NE_CENTER flag's total demand. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Void NE_SetCenterMaxRange(FlagPtr flagP, Float val);
* Set the NE_CENTER flag's max range. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Void NE_SetCenterMaxK(FlagPtr flagP, Int32 val);
* Set the NE_CENTER flag's max K. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Float NE_GetCenterSupply(FlagPtr flagP);
* Get the NE_CENTER flag's supply. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Float NE_GetCenterRange(FlagPtr flagP);
* Get the NE_CENTER flag's range. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Float NE_GetCenterTotalDemand(FlagPtr flagP);
* Get the NE_CENTER flag's total demand. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Float NE_GetCenterMaxRange(FlagPtr flagP);
* Get the NE_CENTER flag's max range. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ Int32 NE_GetCenterMaxK(FlagPtr flagP);
* Get the NE_CENTER flag's max K. Wedo
not check for proper type
* here. It is the client's reponsibility.
*
+ NetviewPtr NE_MakeNetview(NetworkPtr, BStr, NetviewType);
* Makes a Netview of the specified type from the given Network. By
* default the Netview has all layers and the first weight in each layer.
*
+ Void NE_DisposeNetview(NetviewPtr);
* Disposes of the Netview and frees up the memory.
*
+ Void NE_SetNetviewWeight(NetviewPtr, WeightPtr);
* Sets the weight to be returned by traversal queries. The default is the
* first weight (or the weight with WeightKey of 0)
*
+ WeightPtr NE_GetNetviewWeight(NetviewPtr);
* Gets the weight returned by the traversal queries.
*
+ Void NE_SetNetviewSecWeight(NetviewPtr, WeightPtr);
* Sets the secondary weight to be returned by traversal queries. The default
* is NULL.
*
+ WeightPtr NE_GetNetviewSecWeight(NetviewPtr);
* Gets the secondary weight returned by the traversal queries.
*
+ Void NE_SetNetviewBackWeight(NetviewPtr, WeightPtr);
* Sets the backward weight to be used by traversal queries. The default
* is NULL. This is used in hierarchical path and od matrix solvers.
*
+ WeightPtr NE_GetNetviewBackWeight(NetviewPtr);
* Gets the backward weight returned by the traversal queries.
*
+ Void NE_SetNetviewIgnoreJunctionWeight(NetviewPtr, BoolEnum);
* The Netview by default uses junction weight. You can ask it to ignore
* junction weights if not necessary.
*
+ BoolEnum NE_GetNetviewIgnoreJunctionWeight(NetviewPtr);
*
+ Void NE_SetNetviewClientPtr(NetviewPtr, VoidPtr);
* Sets the Netview's ClientPtr.
*
+ VoidPtr NE_GetNetviewClientPtr(NetviewPtr);
* Gets the Netview's ClientPtr.
*
+ Void CCONV NE_SetSolveCB(NetviewPtr, NetworkPtr(*)());
* Set the call back function to be called upon NE_Solve. The call back
* function will be called with netview as the argument. The netviewdo
es
* not have to be NE_CUSTOMVIEW. As a client you can have custom solver for
* any type of Netview.
*
+ BoolEnum CCONV NE_IsSolveCB(NetviewPtr);
* Is there a call back function set for NE_Solve.
*
+ Void CCONV NE_ClearSolveCB(NetviewPtr);
* Clear the call back function.
*
+ Void NE_ClearBarriers(NetviewPtr);
* Clear the barrier information associated with the netview.
*
+ Void NE_SetBarriers(NetviewPtr, BoolEnum (*)(), VoidPtr);
* Set the barrier information for the netview. For all adjacent edges the
* NE_QueryFStarCursor will report only edges that return BOOL_TRUE when
* the handle is passed in to the barrier call back function set here.
* The engine will pass in the client data as the first argument and
* the HandleAttPtr as the second argument to the barrier call back
* function.
*
+ Void NE_OpenLandmarkChannel(NetviewPtr, Int32);
* Open a channel to add a specified number of landmarks
*
+ Void NE_AddLandmark(NetviewPtr, Int32, Int32);
* Adds a given landmark. You need to have opened a landmarkchannel.
* The landmark is specified by giving a key and a value.
*
+ BoolEnum NE_QueryLandmark(NetviewPtr, Int32, Int32Ptr, NE_ActionEnum);
* Query the Landmarks on a specified element. The way to use this is
* to start by giving an action of NE_FIND. If there are no landmarks
* with the specified key a BOOL_FALSE is returned. Additional landmarks
* with the same key can be queried by subsequent calls with the NE_NEXT
* action until BOOL_FALSE is returned.
*
+ Void NE_CloseLandmarkChannel(NetviewPtr);
* Closes the landmark channel, clearing all landmarks set.
*
+ NetworkPtr NE_GetSourceNetwork(NetviewPtr);
* Returns the Network handle for the source Network.
*
+ Void NE_SetResultNetwork(NetviewPtr, NetworkPtr);
* Sets the result Network as specified.
*
+ NetworkPtr NE_GetResultNetwork(NetviewPtr);
* Returns the Network handle for the result Network.
*
+ NetworkPtr NE_Solve(NetviewPtr);
* The operation depends on the type of Netview. This is the default
* solver that works on any Netview. If the type is
* GENVIEW - Generic or client specified view.
* PATHVIEW - Solves a shortest path.
* ALLOCATEVIEW - Solves an allocate connected.
* ODMATRIXVIEW - Solves for just the distances.
*
+ NetworkPtr NE_SolveTour(NetviewPtr, NetviewPtr);
* This operation works only on PATHVIEWs. It solves a traveling salesman
* tour from the origin to the destination. The first netview is the
* PATHVIEW and the second netview is an ODMATRIXVIEW that is necessary to
* compute the ODMATRIX. If the second netview is null, Solve will still
* work. However, if the client has set up barriers and/or non-default
* weights, an ODMATRIXVIEW can be passed in.
*
+ Void NE_SetStatus(NetviewPtr, BoolEnum);
* This sets a call back function to be used to allow interrupt of the
* solving operation. If the call back function returns true, the solver
* breaks out returning NULL.
*
+ BoolEnum NE_GetStatus(NetviewPtr);
* Gets the status using the call back function.
*
+ Void NE_ClearStatus(NetviewPtr);
* Clear any set status call back.
*
+ Void NE_SetStart(NetviewPtr, FlagPtr);
* Set the given stop as start.
*
+ Void NE_SetEnd(NetviewPtr, FlagPtr);
* Set the given stop as end.
*
+ FlagPtr NE_GetStart(NetviewPtr);
* Get the start stop.
*
+ FlagPtr NE_GetEnd(NetviewPtr);
* Get the end stop.
*
+ Void NE_SetViaStop(NetviewPtr, FlagPtr);
* Sets the via stop while traversing from the Start to end.
The stop should
* have a precedence value set.
*
+ Void NE_SetTotalImpedance(NetviewPtr, WeightValue);
* Sets the total impedance.
*
+ Int32 NE_GetNumViaStops(NetviewPtr);
* Gets the number of via stops to visit while traversing from the Start
* to end.
*
+ BoolEnum NE_QueryViaStops(NetviewPtr, FlagPtr *);
* Queries the via stops to visit. The client needs to allocate memory for
* the FlagPtr array returned.
*
+ FlagPtr NE_GetNthVisitedStop(NetviewPtr, Int32);
* Gets the Nth visited stop after Path or Tour has been computed.
* N ranges from 1 to NumViaStops + 2. The first stop will always
* be the start and the last one will be the end.
*
+ WeightValue NE_GetTotalImpedance(NetviewPtr);
* Return the total impedance.
*
+ Void NE_SetCenter(NetviewPtr, FlagPtr);
* Set the center based on the given flag. No type checking isdo
ne and
* it is the client's responsibility to pass in the right netview. The
* corresponding flag is added to the list of centers.
*
+ Int32 NE_GetNumCenters(NetviewPtr);
* Get the total number of centers that are part of the netview. No type
* checking isdo
ne and it is the client's responsibility to pass in the
* right netview.
*
+ BoolEnum NE_QueryCenters(NetviewPtr, FlagPtr *);
* Queries the centers from the netview. No type checking isdo
ne. The
* client is also responsible for passing in the memory required to fill
* in the array of FlagPtrs returned.
*
+ Int32 NE_GetNumTravelTimes(FlagPtr);
* Get the number of travel time intervals associated with the flag
*
+ Void NE_SetTravelTimes(FlagPtr, Int32, Float *);
* Set the travel times associated with a flag.
*
+ Void NE_QueryTravelTimes(FlagPtr, Float *);
* Queries the travel times from the flag. The client is
* responsbile for passing in the memory required to fill in the
* array of travel times returned.
*
+ Void NE_SetOrigin(NetviewPtr, FlagPtr);
* Sets the origin for the netview.
*
+ Void NE_SetDestination(NetviewPtr, FlagPtr);
* Sets the destination for the netview.
*
+ Int32 NE_GetNumOrigins(NetviewPtr);
* Gets the number of origins for the netview.
*
+ Int32 NE_GetNumDestinations(NetviewPtr);
* Gets the number of destinations for the netview.
*
+ BoolEnum NE_QueryOrigins(NetviewPtr, FlagPtr *);
* Queries the origins for the netview. It is the client's responsibility
* to allocate memory for the FlagPtr array.
*
+ BoolEnum NE_QueryDestinations(NetviewPtr, FlagPtr *);
* Queries the destinations for the netview. It is the client's responsibility
* to allocate memory for the FlagPtr array.
*
+ Void NE_SetODImpedances(NetviewPtr, FlagPtr, Float *);
* Sets the impedances for the netview's origin flag. It requires
* NumDestinations impedances to be passed in the Float array. It also
* requires that there be a one-to-one correspondence between destination i
* and impedance for the origin. An impedance of -1 implies that there
* is no path from the origin to the destination.
*
+ Void NE_SetSecODImpedances(NetviewPtr, FlagPtr, Float *);
* Applicable only when solved with the netview having secondary weight.
* Sets the secondary impedances for the netview's origin flag. It requires
* NumDestinations impedances to be passed in the Float array. It also
* requires that there be a one-to-one correspondence between destination i
* and impedance for the origin. An impedance of -1 implies that there
* is no path from the origin to the destination.
*
+ BoolEnum NE_QueryODImpedances(NetviewPtr, FlagPtr, Float *);
* Queries the impedances for the netview's origin flag. It requires the client
* to allocate Float array of size NumDestinations. There is a one-to-one
* correspondence between destination i and impedance for the origin. An
* impedance of -1 implies that there is no path from the origin to the
* destination.
*
+ BoolEnum NE_QuerySecODImpedances(NetviewPtr, FlagPtr, Float *);
* Applicable only when solved with the netview having secondary weight.
* Queries the secondary impedances for the netview's origin flag. It requires
* the client to allocate Float array of size NumDestinations. There is a
* one-to-one correspondence between destination i and impedance for the
* origin. An impedance of -1 implies that there is no path from the origin to
* the destination.
*
+ FStarCursorAttPtr NE_MakeFStarCursor(NetviewPtr);
* Makes a forward star cursor from the Netview.
*
+ Void NE_DisposeFStarCursor(FStarCursorAttPtr);
* Disposes of the forward star cursor and frees the memory.
*
+ BoolEnum NE_QueryFStarCursor(FStarCursorAttPtr);
* Query the forward star for specified atJunction and fromEdge.
*
+ Void CCONV NE_SetHiSearchMaxRange(NetviewPtr, Float);
* Sets the maximum range for exact solution for Netview of type NE_HIPATHVIEW.
* If the range is set to a very large value, it will always find the exact path
* because it never looks at the higher level network. By controlling this value
* we can increase the performance because we limit how much it searches on the
* complete network before switching to the higher level network to find a path.
*
+ Float CCONV NE_GetHiSearchMaxRange(NetviewPtr);
* Returns the maximum range for exact solution for Netview of type NE_HIPATHVIEW
*
+ Void CCONV NE_SetHiNetName(NetviewPtr, BStr);
* Sets the name of the higher level network for Netview of type NE_HIPATHVIEW or
* NE_HIODMATRIXVIEW
*
*/
Void CCONV NE_InitNetworkEngine(Void);
Void CCONV NE_ExitNetworkEngine(Void);
NetworkPtr CCONV NE_CreateNetwork(NetworkAttPtr);
BoolEnum CCONV NE_ResetNetwork(NetworkPtr);
Void CCONV NE_DeleteNetwork(BStr);
NetworkPtr CCONV NE_OpenNetwork(BStr, AccessModeEnum);
Void CCONV NE_CloseNetwork(NetworkPtr);
Void CCONV NE_CloseAndDeleteNetwork(NetworkPtr);
BoolEnum CCONV NE_QueryNetworkAttributes(NetworkPtr, NetworkAttPtr);
BoolEnum CCONV NE_IsNetwork(BStr);
BoolEnum CCONV NE_IsNetworkWritable(NetworkPtr);
Void CCONV NE_OpenNetworkFiles(NetworkPtr);
Void CCONV NE_CloseNetworkFiles(NetworkPtr);
BoolEnum CCONV NE_IsNetworkFilesOpen(NetworkPtr);
UInt32 CCONV NE_GetNumElements(NetworkPtr, ElementTypeEnum);
BoolEnum CCONV NE_QueryVersion(NetworkPtr, UInt32Ptr, UInt32Ptr);
IndexTypeEnum CCONV NE_GetIndexType(NetworkPtr);
Void CCONV NE_SetIndexType(NetworkPtr, IndexTypeEnum);
BoolEnum CCONV NE_QueryElementByID(NetworkPtr, ElementTypeEnum, IDAttPtr,
HandleAttPtr);
BoolEnum CCONV NE_QueryElementID(NetworkPtr, HandleAttPtr, IDAttPtr);
BoolEnum CCONV NE_QueryElementDef(NetworkPtr, HandleAttPtr, ElementTypePtr,
ElementDefPtr);
BoolEnum CCONV NE_QueryElementWeightVal(NetworkPtr, HandleAttPtr, WeightPtr,
WeightValuePtr);
BoolEnum CCONV NE_QueryElementWeightVals(NetworkPtr, HandleAttPtr, WeightValuePtr);
NetBrowsePtr CCONV NE_StartElementList(NetworkPtr, ElementTypeEnum);
Void CCONV NE_StopElementList(NetBrowsePtr);
BoolEnum CCONV NE_QueryNextElement(NetBrowsePtr, IDAttPtr, HandleAttPtr);
BoolEnum CCONV NE_QueryPrevElement(NetBrowsePtr, IDAttPtr, HandleAttPtr);
Void CCONV NE_SeekFirstElement(NetBrowsePtr);
Void CCONV NE_SeekLastElement(NetBrowsePtr);
BoolEnum CCONV NE_SeekThisElement(NetBrowsePtr, HandleAttPtr);
NetEditPtr CCONV NE_StartUpdateNetwork(NetworkPtr);
Void CCONV NE_StopUpdateNetwork(NetEditPtr);
BoolEnum CCONV NE_IsUpdateNetwork(NetworkPtr);
LayerPtr CCONV NE_AddLayer(NetEditPtr, LayerAttPtr);
UInt32 CCONV NE_GetNumLayers(NetworkPtr);
LayerPtr CCONV NE_GetLayerByName(NetworkPtr, BStr);
LayerPtr CCONV NE_GetLayerByID(NetworkPtr, Int32);
LayerPtr CCONV NE_GetLayerByKey(NetworkPtr, UInt32);
BoolEnum CCONV NE_QueryLayerAttributes(LayerPtr, LayerAttPtr);
UInt32 CCONV NE_GetLayerKey(LayerPtr);
WeightPtr CCONV NE_AddWeight(NetEditPtr, WeightAttPtr);
UInt32 CCONV NE_GetNumWeights(NetworkPtr);
WeightPtr CCONV NE_GetWeightByName(NetworkPtr, BStr);
WeightPtr CCONV NE_GetWeightIByName(NetworkPtr, BStr);
WeightPtr CCONV NE_GetWeightByID(NetworkPtr, Int32);
WeightPtr CCONV NE_GetWeightByKey(NetworkPtr, UInt32);
BoolEnum CCONV NE_QueryWeightAttributes(WeightPtr, WeightAttPtr);
UInt32 CCONV NE_GetWeightKey(WeightPtr);
Void CCONV NE_AddElement(NetEditPtr, ElementAttPtr);
Void CCONV NE_AddElementByID(NetEditPtr, ElementAttPtr, IDAttPtr, IDAttPtr,
IDAttPtr);
Void CCONV NE_SetElementRange(NetEditPtr, HandleAttPtr, PercentValue, PercentValue);
Void CCONV NE_SetElementWeightVal(NetEditPtr, HandleAttPtr, WeightPtr, WeightValuePtr);
Void CCONV NE_SetElementWeightVals(NetEditPtr, HandleAttPtr, WeightValuePtr);
FlagPtr CCONV NE_MakeFlag(FlagAttPtr);
BoolEnum CCONV NE_QueryFlagAtt(FlagPtr, FlagAttPtr);
Void CCONV NE_DisposeFlag(FlagPtr);
Void CCONV NE_SetFlagX(FlagPtr,do
uble x);
Void CCONV NE_SetFlagY(FlagPtr,do
uble y);
Void CCONV NE_SetFlagClientPtr(FlagPtr, Void *);
Void* CCONV NE_GetFlagClientPtr(FlagPtr);
Double CCONV NE_GetFlagX(FlagPtr);
Double CCONV NE_GetFlagY(FlagPtr);
Void CCONV NE_SetStopDemand(FlagPtr, Float);
Void CCONV NE_SetStopImpedance(FlagPtr, Float);
Void CCONV NE_SetStopPrecedence(FlagPtr, Float);
Void CCONV NE_SetStopCumulDemand(FlagPtr, Float);
Void CCONV NE_SetStopCumulImpedance(FlagPtr, Float);
Void CCONV NE_SetStopOutOrder(FlagPtr, Int32);
Float CCONV NE_GetStopDemand(FlagPtr);
Float CCONV NE_GetStopImpedance(FlagPtr);
Float CCONV NE_GetStopPrecedence(FlagPtr);
Float CCONV NE_GetStopCumulDemand(FlagPtr);
Float CCONV NE_GetStopCumulImpedance(FlagPtr);
Int32 CCONV NE_GetStopOutOrder(FlagPtr);
Void CCONV NE_SetCenterSupply(FlagPtr, Float);
Void CCONV NE_SetCenterRange(FlagPtr, Float);
Void CCONV NE_SetCenterMaxRange(FlagPtr, Float);
Void CCONV NE_SetCenterMaxK(FlagPtr, Int32);
Float CCONV NE_GetCenterSupply(FlagPtr);
Float CCONV NE_GetCenterRange(FlagPtr);
Float CCONV NE_GetCenterMaxRange(FlagPtr);
Int32 CCONV NE_GetCenterMaxK(FlagPtr);
Int32 CCONV NE_GetNumTravelTimes(FlagPtr);
Void CCONV NE_SetTravelTimes(FlagPtr, Int32, Float *);
Void CCONV NE_QueryTravelTimes(FlagPtr, Float *);
NetviewPtr CCONV NE_MakeNetview(NetworkPtr, BStr, NetviewType);
Void CCONV NE_DisposeNetview(NetviewPtr);
Void CCONV NE_SetNetviewWeight(NetviewPtr, WeightPtr);
WeightPtr CCONV NE_GetNetviewWeight(NetviewPtr);
Void CCONV NE_SetNetviewBackWeight(NetviewPtr, WeightPtr);
WeightPtr CCONV NE_GetNetviewBackWeight(NetviewPtr);
Void CCONV NE_SetNetviewSecWeight(NetviewPtr, WeightPtr);
WeightPtr CCONV NE_GetNetviewSecWeight(NetviewPtr);
Void CCONV NE_SetNetviewIgnoreJunctionWeight(NetviewPtr, BoolEnum);
BoolEnum CCONV NE_GetNetviewIgnoreJunctionWeight(NetviewPtr);
Void CCONV NE_SetNetviewClientPtr(NetviewPtr, VoidPtr);
VoidPtr CCONV NE_GetNetviewClientPtr(NetviewPtr);
Void CCONV NE_SetSolveCB(NetviewPtr, NetworkPtr(*)());
BoolEnum CCONV NE_IsSolveCB(NetviewPtr);
Void CCONV NE_ClearSolveCB(NetviewPtr);
Void CCONV NE_ClearBarriers(NetviewPtr);
Void CCONV NE_SetBarriers(NetviewPtr, BoolEnum (*)(), VoidPtr);
Void CCONV NE_OpenLandmarkChannel(NetviewPtr, Int32);
Void CCONV NE_AddLandmark(NetviewPtr, Int32, Int32);
BoolEnum CCONV NE_QueryLandmark(NetviewPtr, Int32, Int32Ptr, NE_ActionEnum);
Void CCONV NE_CloseLandmarkChannel(NetviewPtr);
NetworkPtr CCONV NE_GetSourceNetwork(NetviewPtr);
Void CCONV NE_SetResultNetwork(NetviewPtr, NetworkPtr);
NetworkPtr CCONV NE_GetResultNetwork(NetviewPtr);
NetworkPtr CCONV NE_Solve(NetviewPtr);
NetworkPtr CCONV NE_SolveTour(NetviewPtr, NetviewPtr);
Void CCONV NE_SetStatus(NetviewPtr, BoolEnum (*)());
BoolEnum CCONV NE_GetStatus(NetviewPtr);
Void CCONV NE_ClearStatus(NetviewPtr);
Void CCONV NE_SetCenter(NetviewPtr, FlagPtr);
Int32 CCONV NE_GetNumCenters(NetviewPtr);
BoolEnum CCONV NE_QueryCenters(NetviewPtr, FlagPtr *);
Void CCONV NE_SetStart(NetviewPtr, FlagPtr);
Void CCONV NE_SetEnd(NetviewPtr, FlagPtr);
Void CCONV NE_SetViaStop(NetviewPtr, FlagPtr);
Void CCONV NE_SetTotalImpedance(NetviewPtr, WeightValue);
FlagPtr CCONV NE_GetStart(NetviewPtr);
FlagPtr CCONV NE_GetEnd(NetviewPtr);
Int32 CCONV NE_GetNumViaStops(NetviewPtr);
BoolEnum CCONV NE_QueryViaStops(NetviewPtr, FlagPtr *);
FlagPtr CCONV NE_GetNthVisitedStop(NetviewPtr, Int32);
WeightValue CCONV NE_GetTotalImpedance(NetviewPtr);
Void CCONV NE_SetOrigin(NetviewPtr, FlagPtr);
Void CCONV NE_SetDestination(NetviewPtr, FlagPtr);
Int32 CCONV NE_GetNumOrigins(NetviewPtr);
Int32 CCONV NE_GetNumDestinations(NetviewPtr);
BoolEnum CCONV NE_QueryOrigins(NetviewPtr, FlagPtr *);
BoolEnum CCONV NE_QueryDestinations(NetviewPtr, FlagPtr *);
Void CCONV NE_SetODImpedances(NetviewPtr, FlagPtr, Float *);
Void CCONV NE_SetSecODImpedances(NetviewPtr, FlagPtr, Float *);
BoolEnum CCONV NE_QueryODImpedances(NetviewPtr, FlagPtr, Float *);
BoolEnum CCONV NE_QuerySecODImpedances(NetviewPtr, FlagPtr, Float *);
Void CCONV NE_SetHiSearchMaxRange(NetviewPtr, Float);
Float CCONV NE_GetHiSearchMaxRange(NetviewPtr);
Void CCONV NE_SetHiNetName(NetviewPtr, BStr);
FStarCursorAttPtr CCONV NE_MakeFStarCursor(NetviewPtr);
Void CCONV NE_DisposeFStarCursor(FStarCursorAttPtr);
SecFStarCursorAttPtr CCONV NE_MakeSecFStarCursor(FStarCursorAttPtr);
Void CCONV NE_DisposeSecFStarCursor(SecFStarCursorAttPtr);
BoolEnum CCONV NE_QueryFStarCursor(FStarCursorAttPtr);
BoolEnum CCONV NE_QueryBothFStarCursor(FStarCursorAttPtr, SecFStarCursorAttPtr);
Void CCONV NE_SetLastErrorStat(NE_ErrorStatEnum);
NE_ErrorStatEnum CCONV NE_GetLastErrorStat(Void);
/**************************************************************************
* SafeArray Data Types and APIs
*
* These Data Types and APIs are the same as the generic ones. The only
* difference is that they read from and write into safearrays.
**************************************************************************/
#ifdef _SARRAY
typedef struct {
ElementTypeEnum Type;
HandleAttRec HAtt;
IDAttRec IDRec;
ElementDefRec ElDef;
LPSAFEARRAY WeightVals;
} SAElementAttRec, *SAElementAttPtr;
typedef struct {
NetviewPtr NvP;
FStarCursorPtr FsP;
HandleAttRec AtJunction;
HandleAttRec FromEdge;
WeightValue AtJunctionWeight;
UInt32 NumReturned;
LPSAFEARRAY ToJunctions;
LPSAFEARRAY ToEdges;
LPSAFEARRAY ToEdgeWeights;
LPSAFEARRAY ToTurns;
LPSAFEARRAY ToTurnWeights;
} SAFStarCursorAttRec, *SAFStarCursorAttPtr;
typedef struct {
WeightValue SecAtJunctionWeight;
LPSAFEARRAY SecToEdgeWeights;
LPSAFEARRAY SecToTurns;
LPSAFEARRAY SecToTurnWeights;
} SASecFStarCursorAttRec, *SASecFStarCursorAttPtr;
Void CCONV NE_SAAddElement(NetEditPtr, SAElementAttPtr);
Void CCONV NE_SAAddElementByID(NetEditPtr, SAElementAttPtr, IDAttPtr, IDAttPtr,
IDAttPtr);
BoolEnum CCONV NE_SAQueryElementWeightVals(NetworkPtr, HandleAttPtr, LPSAFEARRAY*);
Void CCONV NE_SASetElementWeightVals(NetEditPtr, HandleAttPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQueryViaStops(NetviewPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQueryCenters(NetviewPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQueryOrigins(NetviewPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQueryDestinations(NetviewPtr, LPSAFEARRAY*);
Void CCONV NE_SASetODImpedances(NetviewPtr, FlagPtr, LPSAFEARRAY*);
Void CCONV NE_SASetSecODImpedances(NetviewPtr, FlagPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQueryODImpedances(NetviewPtr, FlagPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQuerySecODImpedances(NetviewPtr, FlagPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAQueryServiceFlags(NetviewPtr, LPSAFEARRAY*);
Void CCONV NE_SASetTravelTimes(FlagPtr, Int32, LPSAFEARRAY*);
Void CCONV NE_SAQueryTravelTimes(FlagPtr, LPSAFEARRAY*);
BoolEnum CCONV NE_SAMakeFStarCursor(NetviewPtr, SAFStarCursorAttPtr);
Void CCONV NE_SADisposeFStarCursor(SAFStarCursorAttPtr);
BoolEnum CCONV NE_SAMakeSecFStarCursor(SAFStarCursorAttPtr, SASecFStarCursorAttPtr);
Void CCONV NE_SADisposeSecFStarCursor(SASecFStarCursorAttPtr);
BoolEnum CCONV NE_SAQueryFStarCursor(SAFStarCursorAttPtr);
BoolEnum CCONV NE_SAQueryBothFStarCursor(SAFStarCursorAttPtr, SASecFStarCursorAttPtr);
#endif /* _SARRAY */
#endif
