mi32/mnetfunc.h

Go to the documentation of this file.

#ifndef  INC_MI32_MNETFUNC_H
#define  INC_MI32_MNETFUNC_H

#ifndef  INC_RVC_OBJECTNAME_H
#include <rvc/objectname.h>
#endif

namespace RVC {
   class OBJITEM;
   }

struct COLOR;

/***********************************************************************
*
*     Defines
*
************************************************************************/

#define     NETWORK_TABLE_Line                  0
#define     NETWORK_TABLE_Turn                  1
#define     NETWORK_TABLE_Barrier               2
#define     NETWORK_TABLE_Angle                 3
#define     NETWORK_TABLE_Count                 4

#define     NETWORK_ALLOCATION_In               0
#define     NETWORK_ALLOCATION_Out              1

#define     NETWORK_LINE_DIRECTION_FromTo       0
#define     NETWORK_LINE_DIRECTION_ToFrom       1

#define     NETWORK_LINE_DIRECTION_Disable      0
#define     NETWORK_LINE_DIRECTION_Enable       1

#define     NETWORK_NODE_BARRIER_Off            0
#define     NETWORK_NODE_BARRIER_On             1

#define     NETWORK_ANGLE_MAX                   360


/***********************************************************************
*
*     Structures
*
************************************************************************/

typedef void *MNETWORKHANDLE;
typedef void *MNETWORKSTOPHANDLE;
typedef void *MNETWORKCENTERHANDLE;
typedef void *MNETWORKROUTEHANDLE;
typedef void *MNETWORKMULTIROUTEHANDLE;
typedef void *MNETWORKALLOCATIONHANDLE;

typedef int (*MnetworkLineNameCallbackFunc)(void*, INT32, MIUNICODE*, int);

/***********************************************************************
*
*     Function Prototypes
*
************************************************************************/

#if defined(__cplusplus)
extern "C" {
#endif




// Main functions

int MnetworkMainInit (
   MNETWORKHANDLE *handle,             
   const RVC::OBJITEM& VectObjItem     
   );

int MnetworkMainFree (
   MNETWORKHANDLE *handle              
   );

int MnetworkMainCreateStop (
   MNETWORKHANDLE handle,              
   MNETWORKSTOPHANDLE *stopHandle      
   );

int MnetworkMainCreateCenter (
   MNETWORKHANDLE handle,              
   MNETWORKCENTERHANDLE *centerHandle  
   );

int MnetworkMainSetDefault (
   MNETWORKHANDLE handle               
   );

int MnetworkMainIsTable (
   MNETWORKHANDLE handle,              
   const RVC::OBJECTNAME& tablename,               
   UINT32 tabletype                    
   );
   
int MnetworkMainGetTableNames (
   MNETWORKHANDLE handle,              
   RVC::OBJECTNAME **tablename,           
   INT32 *tablecount,                  
   UINT32 tabletype                    
   );
   
int MnetworkMainReadTable (
   MNETWORKHANDLE handle,              
   const RVC::OBJECTNAME& tablename,               
   UINT32 tabletype                    
   );

int MnetworkMainWriteTable (
   MNETWORKHANDLE handle,              
   RVC::OBJECTNAME& tablename,               
   UINT32 tabletype                    
   ); 

int MnetworkMainSetLineNameAsCallback (
   MNETWORKHANDLE handle,              
   MnetworkLineNameCallbackFunc cbfunc,
   void* cbdata                        
   );

int MnetworkMainSetLineNameAsTableAndField (
   MNETWORKHANDLE handle,              
   RVC::OBJECTNAME& tablename,               
   RVC::OBJECTNAME& fieldname                
   );

INT32 MnetworkLineGetNumber (
   MNETWORKHANDLE handle               
   );

int MnetworkLineIsUpdated (
   MNETWORKHANDLE handle               
   );

int MnetworkLineSetImpedance (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   int direction,                      
   DOUBLE impedance                    
   );

int MnetworkLineGetImpedance (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   int direction,                      
   DOUBLE *impedance                   
   );

int MnetworkLineSetDemand (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   DOUBLE demand                       
   );

int MnetworkLineGetDemand (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   DOUBLE *demand                      
   );

int MnetworkLineSetDirectionState (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   int direction,                      
   int state                           
   );

int MnetworkLineGetDirectionState (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   int direction,                      
   int *state                          
   );

int MnetworkLineGetName (
   MNETWORKHANDLE handle,              
   INT32 line,                         
   MIUNICODE *name,                    
   int size                            
   );

INT32 MnetworkLineGetNodeFrom (
   MNETWORKHANDLE handle,              
   INT32 line                          
   );

INT32 MnetworkLineGetNodeTo (
   MNETWORKHANDLE handle,              
   INT32 line                          
   );

INT32 MnetworkLineGetClosest (
   MNETWORKHANDLE handle,              
   DPOINT2D *point,                    
   DOUBLE radius                       
   );

INT32 MnetworkNodeGetNumber (
   MNETWORKHANDLE handle               
   );

int MnetworkNodeSetBarrierState (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   int state                           
   );

int MnetworkNodeGetBarrierState (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   int *state                          
   );

int MnetworkNodeGetName (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   MIUNICODE *name,                    
   int size                            
   );

int MnetworkNodeGetNumberOfLines (
   MNETWORKHANDLE handle,              
   INT32 node                          
   );

INT32 MnetworkNodeGetLine (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   int position                        
   );

INT32 MnetworkNodeGetClosest (
   MNETWORKHANDLE handle,              
   DPOINT2D *point,                    
   DOUBLE radius                       
   );

int MnetworkBarrierIsUpdated (
   MNETWORKHANDLE handle               
   );

int MnetworkTurnSetImpedance (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   int in,                             
   int out,                            
   DOUBLE impedance                    
   );

int MnetworkTurnGetImpedance (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   int in,                             
   int out,                            
   DOUBLE *impedance                   
   );

int MnetworkTurnGetAngle (
   MNETWORKHANDLE handle,              
   INT32 node,                         
   int in,                             
   int out,                            
   DOUBLE *angle                       
   );

int MnetworkTurnIsUpdated (
   MNETWORKHANDLE handle               
   );

int MnetworkAngleApply (
   MNETWORKHANDLE handle               
   );

int MnetworkAngleIsUpdated (
   MNETWORKHANDLE handle               
   );

int MnetworkAngleSetImpedance (
   MNETWORKHANDLE handle,              
   int angle,                          
   DOUBLE impedance                    
   );

int MnetworkAngleGetImpedance (
   MNETWORKHANDLE handle,              
   int angle,                          
   DOUBLE *impedance                   
   );

// Stop functions

int MnetworkStopCalculateRoute (
   MNETWORKSTOPHANDLE stopHandle,      
   MNETWORKROUTEHANDLE *routeHandle    
   );

int MnetworkStopClone (
   MNETWORKSTOPHANDLE stopHandle,      
   MNETWORKSTOPHANDLE *cloneStopHandle 
   );

int MnetworkStopFree (                 
   MNETWORKSTOPHANDLE *stopHandle      
   );

int MnetworkStopIsUpdated (
   MNETWORKSTOPHANDLE stopHandle       
   );

int MnetworkStopIsTable (
   MNETWORKSTOPHANDLE stopHandle,      
   const RVC::OBJECTNAME& tablename                
   );
   
int MnetworkStopGetTableNames (
   MNETWORKSTOPHANDLE stopHandle,      
   RVC::OBJECTNAME **tablename,           
   INT32 *tablecount                   
   );
   
int MnetworkStopOpenTable (
   MNETWORKSTOPHANDLE stopHandle,      
   const RVC::OBJECTNAME& tablename                
   );

int MnetworkStopSaveTable (
   MNETWORKSTOPHANDLE stopHandle,      
   RVC::OBJECTNAME& tablename                
   );
    
int MnetworkStopAdd (
   MNETWORKSTOPHANDLE stopHandle,      
   INT32 node,                         
   int position                        
   );

int MnetworkStopDelete (
   MNETWORKSTOPHANDLE stopHandle,      
   int *positions,                     
   int numPositions                    
   );

int MnetworkStopDeleteAll (
   MNETWORKSTOPHANDLE stopHandle       
   );

int MnetworkStopMove (
   MNETWORKSTOPHANDLE stopHandle,      
   int oldPosition,                    
   int newPosition                     
   );

INT32 MnetworkStopGet (
   MNETWORKSTOPHANDLE stopHandle,      
   int position                        
   );

int MnetworkStopGetNumber (
   MNETWORKSTOPHANDLE stopHandle       
   );

int MnetworkStopGetAll (
   MNETWORKSTOPHANDLE stopHandle,      
   INT32 **nodes,                      
   INT32 *numNodes                     
   );

int MnetworkStopSetDemand (
   MNETWORKSTOPHANDLE stopHandle,      
   int position,                       
   DOUBLE demand                       
   );

int MnetworkStopGetDemand (
   MNETWORKSTOPHANDLE stopHandle,      
   int position,                       
   DOUBLE *demand                      
   );


// MultiRoute functions

int MnetworkCalculateMultiRoute (
   MNETWORKHANDLE handle,                      
   INT32 source,                               
   INT32 *destinations,                        
   INT32 numDestinations,                      
   MNETWORKROUTEHANDLE *multiRouteHandle       
   );

int MnetworkMultiRouteGetRoute (
   MNETWORKMULTIROUTEHANDLE multiRouteHandle,  
   INT32 destination,                          
   MNETWORKROUTEHANDLE *routeHandle            
   );

int MnetworkMultiRouteFree (
   MNETWORKMULTIROUTEHANDLE *multiRouteHandle   
   );

// Route functions

int MnetworkRouteRestoreStop (
   MNETWORKROUTEHANDLE routeHandle,    
   MNETWORKSTOPHANDLE *stopHandle      
   );

int MnetworkRouteFree (
   MNETWORKROUTEHANDLE *routeHandle    
   );

INT32 MnetworkRouteGetNumberOfNodes (
   MNETWORKROUTEHANDLE routeHandle
   );

INT32 MnetworkRouteGetNode (
   MNETWORKROUTEHANDLE routeHandle,    
   int position                        
   );

INT32 MnetworkRouteGetNumberOfLines (
   MNETWORKROUTEHANDLE routeHandle     
   );

INT32 MnetworkRouteGetLine (
   MNETWORKROUTEHANDLE routeHandle,    
   int position                        
   );

int MnetworkRouteIsNodeStop (
   MNETWORKROUTEHANDLE routeHandle,    
   int position                        
   );

int MnetworkRouteIsNodeTurn (
   MNETWORKROUTEHANDLE routeHandle,    
   int position                        
   );

int MnetworkRouteGetLineDirection (
   MNETWORKROUTEHANDLE routeHandle,    
   int position                        
   );

int MnetworkRouteGetResultAsNodes (
   MNETWORKROUTEHANDLE routeHandle,    
   INT32 **nodes,                      
   INT32 *numNodes                     
   );

int MnetworkRouteGetResultAsLines (
   MNETWORKROUTEHANDLE routeHandle,    
   INT32 **lines,                      
   INT32 *numLines                     
   );

int MnetworkRouteGetResultAsPoints (
   MNETWORKROUTEHANDLE routeHandle,    
   DPOINT2D **points,                  
   INT32 *numPoints                    
   );

int MnetworkRouteGetReport (
   MNETWORKROUTEHANDLE routeHandle,    
   MIUNICODE **report                     
   );

// Center functions

int MnetworkCenterCalculateAllocation (
   MNETWORKCENTERHANDLE centerHandle,           
   int type,                                    
   MNETWORKALLOCATIONHANDLE *allocationHandle   
   );

int MnetworkCenterClone (
   MNETWORKCENTERHANDLE centerHandle,           
   MNETWORKCENTERHANDLE *cloneCenterHandle      
   );

int MnetworkCenterFree (
   MNETWORKCENTERHANDLE *centerHandle  
   );

int MnetworkCenterIsUpdated (
   MNETWORKCENTERHANDLE centerHandle   
   ); 

int MnetworkCenterIsTable (
   MNETWORKCENTERHANDLE centerHandle,  
   const RVC::OBJECTNAME& tablename                
   );
   
int MnetworkCenterGetTableNames (
   MNETWORKCENTERHANDLE centerHandle,  
   RVC::OBJECTNAME **tablename,           
   INT32 *tablecount                   
   );
   
int MnetworkCenterOpenTable (
   MNETWORKCENTERHANDLE centerHandle,  
   const RVC::OBJECTNAME& tablename                
   );

int MnetworkCenterSaveTable (
   MNETWORKCENTERHANDLE centerHandle,  
   RVC::OBJECTNAME& tablename                
   ); 

int MnetworkCenterAdd (
   MNETWORKCENTERHANDLE centerHandle,  
   INT32 node                          
   );

int MnetworkCenterDelete (
   MNETWORKCENTERHANDLE centerHandle,  
   int *positions,                     
   int numPositions                    
   );

int MnetworkCenterDeleteAll (
   MNETWORKCENTERHANDLE centerHandle   
   );

INT32 MnetworkCenterGet (
   MNETWORKCENTERHANDLE centerHandle,  
   int position                        
   );

int MnetworkCenterGetPosition (
   MNETWORKCENTERHANDLE centerHandle,  
   INT32 node                          
   );

int MnetworkCenterGetNumber (
   MNETWORKCENTERHANDLE centerHandle   
   );

int MnetworkCenterGetAll (
   MNETWORKCENTERHANDLE centerHandle,  
   INT32 **nodes,                      
   INT32 *numNodes                     
   );

int MnetworkCenterSetCapacity (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   DOUBLE capacity                     
   );

int MnetworkCenterGetCapacity (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   DOUBLE *capacity                    
   );

int MnetworkCenterSetImpedanceLimit (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   DOUBLE limit                        
   );

int MnetworkCenterGetImpedanceLimit (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   DOUBLE *limit                       
   );

int MnetworkCenterSetImpedanceDelay (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   DOUBLE delay                        
   );

int MnetworkCenterGetImpedanceDelay (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   DOUBLE *delay                       
   );

int MnetworkCenterSetColor (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   COLOR *color                        
   );

int MnetworkCenterGetColor (
   MNETWORKCENTERHANDLE centerHandle,  
   int position,                       
   COLOR *color                        
   );

// Allocation functions

int MnetworkAllocationRestoreCenter (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   MNETWORKCENTERHANDLE *centerHandle           
   );

int MnetworkAllocationFree (
   MNETWORKALLOCATIONHANDLE *allocationHandle   
   );

int MnetworkAllocationGetResultAsPositions (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   INT32 **positions,                           
   INT32 *numPositions                          
   );

int MnetworkAllocationGetType (
   MNETWORKALLOCATIONHANDLE allocationHandle    
   );

int MnetworkAllocationGetReport (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   MIUNICODE **report                              
   );

INT32 MnetworkAllocatedCenterGet (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position                                 
   );

INT32 MnetworkAllocatedCenterGetNumber (
   MNETWORKALLOCATIONHANDLE allocationHandle    
   );

int MnetworkAllocatedCenterGetPosition (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   INT32 node                                   
   );

int MnetworkAllocatedCenterGetColor (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   COLOR *color                                 
   );

INT32 MnetworkAllocatedCenterGetNumberOfLines (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position                                 
   );

int MnetworkAllocatedCenterGetCapacity (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   DOUBLE *capacity                             
   );

int MnetworkAllocatedCenterGetDemand (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   DOUBLE *demand                               
   );

int MnetworkAllocatedCenterGetImpedanceLimit (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   DOUBLE *limit                                
   );

int MnetworkAllocatedCenterGetImpedanceDelay (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   DOUBLE *delay                                
   );

int MnetworkAllocatedCenterGetMaximumImpedance (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   DOUBLE *maximum                              
   );

int MnetworkAllocatedCenterGetAverageImpedance (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   int position,                                
   DOUBLE *average                              
   );

INT32 MnetworkAllocatedLineGetNumber (
   MNETWORKALLOCATIONHANDLE allocationHandle    
   );

int MnetworkAllocatedLineGetPosition (
   MNETWORKALLOCATIONHANDLE allocationHandle,   
   INT32 line                                   
   );


#if defined(__cplusplus)
}                       
#endif

#endif   

---