| \n |
| Microsoft Invisible Computing |
Base Interfaces: IUnknown INameSpace INameRanges IHeap IHeapFactory IModule IProcess IThread IProgram IFile IBaseRtl
Internal Interfaces: IScheduler IPic
Driver Interfaces: IDevice INetDriver IDeviceConstructor IBusDriver
Graphics Interfaces: IFrameBuffer
Usb Interfaces: IUsbSlaveDriver IUsbSlaveController IUsbMasterController IUsbHub IUsbDriver
Network Interfaces: IEndpoint1 IEndpoint IEndpointFactory IBuffer IProtoSW
VirtualMemory Interfaces: IVmView
Soap Interfaces: ISoapFactory IConvert IContinuation ISaxParser ISaxHandler ISoapSerializer IListener IHttpConnector IHttpProcess IWebProtocolFactory ITokenizerFactory ITokenizer
Ws Interfaces: IWsReservation IWsAddressing ICIM_Base ICIM_ManagedSystemElement ICIM_NumericSensor IWsTransfer IDssp IWsManagement IWsManId IWsManConfig IWsEnumeration IWsEventing IWsDiscovery IKeyExchange soapenc soap11 xml soap12 xsd xsi IWsMetadataExchange IWsDeviceProfile ITrustPolicy
WsHelpers Interfaces: ISampling IStatistics IReservationBuilder ITaskBuilder IPlanner IInstigator IWsDiscoveryUtil IWsTargetService IEnum ICimFactory ICimResource
Crypto Interfaces: ICypher ICypherConstructor
Utility Interfaces: ICRuntime IMacros
Samples Interfaces: ISampleCalculator ISensor IRecorder ISntpClient IRobot ITablet IPong ITest ISampleTest ICLRSample IGlove ICIM_Schema ICIM_Catalog IWsManagementListener ICIM_IPMI ICIM_RecordLog IRobotGameController IServiceTutorial1
These interfaces expose basic OS functionality. Most other interfaces derive from the base interfaces.
The MMLite RTOS is built around namespaces and objects. The Base component and other components implement them.
The IUnknown interface provides methods to obtain and manage pointers to interface objects. Every COM object must support the IUnknown interface and all interfaces are derived from it.
The INameSpace interface provides methods for manipulating namespaces and the run-time library provides a function and flags for accessing the system namespace.
INameRanges is an extension of INameSpace that allows registering named ranges and searching in them.
The IHeap interface provides methods for allocating memory.
The IHeapFactory interface is a factory for heaps. It wraps the CreateHeapFrom utility function for a given heap.
The IModule interface provides methods for managing modules and the run-time library provides functions for accessing modules. Modules are loaded with an executable program or a DLL file and reside within a process. A module is usually created using IProcess.LoadImage.
The IProcess interface provides methods for managing processes and the run-time library provides a function for accessing the current process.
The IThread interface provides a method for accessing the process in which the thread was started and the run-time library provides a function for accessing the current thread.
Standardized entry for components that accept command lines.
Provides synchronous I/O for files etc.
Base export table interface.
Interfaces internal to the system.
These interfaces define communication between the thread package and scheduler etc. Most of them do not derive from IUnknown and are not remotable.
Scheduler interface (internal).
Interrupt controller interface (internal).
Interfaces for device drivers.
Most device drivers implement the IDeviceConstructor and IDevice interfaces and inherit methods from the CDevice concrete class.
Basic device driver interface.
Network device driver interface.
Generic constructor for driver cobs.
Interface for bus controllers.
Interfaces for video and 2D/3D graphics.
Mostly TBD at this point.
Basic frame buffer interface.
Intended for direct access to hardware-supported 2D drawing surfaces. Exposes the associated memory (VRAM) and the palette, if present.
Interfaces for handling USB peripherals and drivers.
USB peripherals are implemented in two parts. The IUsbSlaveController handles the actual chip, the IUsbSlaveDriver realizes the desired peripheral.
USB drivers are implemented in multiple parts, at least three parts. The IUsbMasterController handles the actual chip, the Host Controller Interface (HCI) described in the USB specs. The IUsbHub handles USB switches (HUBs) including the root HUB. The IUsbDriver realizes the peripheral driver and top level interface. Sometimes other generic drivers are used on top of the IUsbDriver. Notice that a USB HUB is also a peripheral and must implement the IUsbDriver interface.
See USB Stack.doc for more information.
Slave-side, USB peripheral implementation interface.
Slave-side, USB device controller driver interface.
Interface for USB Host Controller Interface chips (UHCI et al.).
Interface for USB HUBs. NOTE: derives from IUsbMasterController
Master-side, USB peripheral implementation interface (for use by HUBs).
Interfaces for dealing with the protocol stack.
Note that these interfaces are likely to change in the future to facilitate asynchronous operation.
Interface for queueing buffers between two ends.
Network connection sockets.
Constructor and control for EndPoints.
A data item. An mbuf.
A protocol switch, describes one protocol. Modeled after struct protosw found in the Berkeley stack
Interfaces for virtual memory.
Virtual memory is a loadable part of MMLite but some interfaces are always needed. For example IVmView.SwitchTo is called from the context switch path.
Virtual memory view interface.
Interfaces for implementing web services.
HTTP, XML, SOAP, and friends.
SOAP box factory.
The converter provides objects and methods for converting data between different representations, such as XML, native data, managed data, native continuations, managed continuations.
Encapsulates a method call. The object represents a method call, either local or remote, on client or server that is running, future, or completed.
The interface to the SAX XML parser. Pass a Tokenizer object and a Callback interface to an implementation of this interface, and it will parse the XML file being tokenized and call the appropriate callback operations. For more information, refer to a document on SAX, and the ISaxHandler interface defined below. Returns a success code if the parsing was successful, but an error code if it failed somewhere in the middle.
Implementations of this interfaces process XML documents as they are parsed by an ISaxParser implementation.
SOAP Serializer. ISoapSerializer and ISoapConnector are implemented in different COBs because ISoapSerializer is independed on which protocol ISoapConnector is implemented over, such as HTTP, FTP or UDP.
Generic network listener interface. The default implementation provides facilities for listening on a server socket, accepting connections, and dispatching them to access policy and service provision routines provided by the implementation.
SOAP connector.
The connector is also used for sending responses to the current request.
Interface for HTTP processing. Most programs can use the default implementation.
This factory interface is implemented by the HTTP or UDP cob and registered in the current namespace upon COB loading. It provides facilities for the construction and destruction of server instances, and should eventually evolve to provide a memory management interface as well. To access it, lookup COB/http.cob in the system namespace and query.
The Main method starts a server that listens to the URL specified.
Creates instances of ITokenizer implementations.
The purpose of this interface is to encapsulate the tokenizing of string data that is spread over multiple buffers, for example, a sequence of mbufs. The buffers can be the results of reading from either a file interface, or an endpoint interface.
Interfaces for published web services namespaces.
These interfaces correspond to WS-* namespaces.
Real-time reservation header.
WS-Addressing
Sample CIM base class for WS-Management interop workshop. Look for real CIM schema at MSDN.
Base class for most other CIM classes.
Sample CIM class for WS-Management interop workshop. Look for real CIM schema at MSDN.
This particular namespace is a mostly redundant replica of p:NumericSensor but it has a slightly different ns and name.
WS-Transfer provides generic accessor methods for various classes.
WS-Transfer provides generic accessor methods for various classes.
This is so far an incomplete implementation of WS-Management.
WS-Management Identify.
WS-Management config resource.
This is so far an incomplete implementation of WS-Enumeration.
WS-Eventing combined message processing for event sources and sinks.
WS-Discovery combined message processing for clients and target services.
An interface for key management on a home network.
Pseudo-interface for declaring builtin SOAP 1.2 namespace.
Pseudo-interface for declaring builtin SOAP 1.1 namespace.
Pseudo-interface for declaring builtin XML namespace.
Interface for declaring builtin SOAP 1.2 namespace.
Pseudo-interface for declaring builtin XSD subset namespace.
Pseudo-interface for declaring builtin XSI subset namespace.
Ws-MetadataExchange.
WS Device Profile.
Scriptable trust evaluation policies. EXPERIMENTAL.
Internal helper interfaces for the WS-interfaces.
Sampling helper for WsRes.
Sampling helper for WsRes.
Helper for WsRes.
Helper for WsRes.
Helper for WsRes.
Helper for WsRes.
Helper for Ws-Discovery.
Helper for WS-Discovery.
Generic enumerator interface.
Constructor and control interface for WS-Man CIM providers.
Internal resource functions.
Interfaces for cryptographic operations.
Cyphers must implement the ICypherConstructor and ICypher interfaces.
Basic cypher interface.
Generic constructor for cyphers.
Common Language Runtime interfaces.
This interface defines an interface into TinyCLR. It derives from IUnknown and are not remotable.
CLR interface.
Reusable interfaces for implementing various components.
The Utility interfaces implement general purpose functionality that are not necessarily central to the system but can be useful for more than one component.
C runtime functions (pseudo-interface).
Various macros and portability aids (pseudo-interface).
Interface samples for web services.
These are used by sample programs.
An interface for performing addition.
An interface for collecting sensor readings.
An interface for recording sensor readings.
A control interface for the SNTP client.
A control interface for a prototype robot.
An interface that receives data from a Tablet PC WCF client.
An interface for the pong game.
An interface that receives data from a test client.
An interface that receives data from a test client.
CLR sample interface.
A state probing interface for a glove sensor.
This will be filled with WS-Management Catalog. Sample catalog for WS-Management interop workshop. Look for real CIM schema at MSDN.
Sample catalog for WS-Management interop workshop. Look for real CIM schema at MSDN.
Sample listener for WS-Management interop workshop. Look for real schema at MSDN. This is so far an incomplete implementation of WS-Management.
Sample CIM class for WS-Management interop workshop. Look for real CIM schema at MSDN.
Sample CIM class for WS-Management interop workshop. Look for real CIM schema at MSDN.
| ©2006 Microsoft Corporation. All rights reserved. | Terms of Use | Privacy Statement | Accessibility | End User License Agreement |