The Performance Logs and Alerts Protocol (PLA) is presented to the client as a set of interfaces that define an object model. Communication between the client and the server must use [MS-DCOM].
The PLA protocol consists of several interfaces that allow a client to collect and manage information on the server for manageability and diagnostic purposes. At the foundation of this protocol lies the data collector set.
A data collector set is basically an entity made up of one or more data collectors. Both the collector set and its individual collectors are controlled by a set of interfaces, which are identified by PLA-UIDs.
The Idea of Abstracting Data
The process of abstracting data is used to combine similar things into a higher-level classification or grouping.
👉 For example: patients, providers, employees, researchers—all of them are people. In theory, if you group them all as "people," you can have one definition and a single storage area for everyone.
This idea promises simplicity, reduced timeframes, and lower costs. But here’s the challenge:
- A corporation may want to capture different types of information about patients compared to providers, employees, or researchers.
- So, the real question becomes: how do you separate and capture details that are unique to each type while still keeping the data model abstract?
Common Sources of Abstract Models
Abstract models usually come from two main areas:
- Vendors – They promote the idea that one database schema or model can work for any business across industries.
- Generalization of functions – A Service-Oriented Architecture (SOA) can benefit from abstracted models that handle edits, validations, and retrievals of similar data across different domains.
What is an Abstract Data Type (ADT)?
An Abstract Data Type (ADT) is basically an abstraction of a data structure. It defines only the interface, not the implementation details.
- The interface specifies what operations can be performed on the data.
- It does not specify how the operations are implemented or in which programming language.
In simple terms:
- ADTs define the data and the operations that can be performed.
- They do not specify implementation details, because every programming language has its own way of doing things.
👉 Example:
- In C, data structures are implemented using structs.
- In C++, the same concept can be implemented using objects and classes.
Examples of Abstract Data Types
- List → Can be implemented using dynamic arrays or linked lists.
- Queue → You can build it in different ways. The most common are linked list queues, array-based queues, or even using stacks to simulate queue behavior.
- Map → Usually shows up in programming as tree maps, hash maps, or hash tables. The implementation depends on what you’re optimizing for—speed, memory, or ordering.
Abstract Data Type Model
Before jumping into the ADT model, it’s worth clearing up two simple but important ideas:
1. Abstraction
Think of it as hiding the messy stuff inside and only showing the user the useful parts. You don’t care how it works under the hood, just what it does.
2. Encapsulation
This is about bundling things together. Data and the functions that act on it are tied into one single unit, so everything related stays in the same place.
How the ADT Model Works
An ADT model isn’t complicated. It basically includes:
- The data structures you’re using.
- The public functions → what the outside world can use.
- The private functions → what’s kept hidden and only used inside.
The flow goes like this:
- First, encapsulation → you wrap the data and operations into one box (the ADT).
- Then, abstraction → from outside, people only see what they can do with it, not how it actually works inside.
