0
A remote data object is one that would be located on a different "node". For instance, a node the hardware where the operating system resides, which houses a database. Nodes have IP addresses and names. Say that the main database resided on node "Payroll" (10.128.132.10). Via a database link, an object from another node "Accounting" (10.128.142.11) is referenced. An example of this could be a view which pulls data from a table in the Payroll database and joins it to a table in the Accounting database and the view shows data from both nodes.
What else can I help you with?
Advantages and disadvantages of manual data processing?
disadvantages in data manual processing
What field whose data type is can store an OLE object which is an object linked to or embedded in the table?
OLE Object
What is unicast remote object in java?
The UnicastRemoteObject class defines a non-replicated remote object whose references are valid only while the server process is alive. The UnicastRemoteObject class provides support for point-to-point active object references (invocations, parameters, and results) using TCP streams.
Example of lazy copy in c plus plus?
Lazy copying is a hybrid of the standard shallow-copy and deep-copy mechanisms. Objects that are copy constructed or assigned from existing instances will initially be shallow-copied, meaning their dynamic data members will share the same memory. When an object is mutated whilst sharing memory, its data will be deep copied so as not to affect the shared instances. In other words, deep-copying is postponed until it is actually required (if at all). For large and complex objects, this can offer a significant memory saving and a major performance boost as a shallow copy is significantly faster than a deep copy, and sharing memory obviously consumes less memory. In order to implement lazy copying, it is necessary for each instance to be fully aware of all the instances it shares memory with. One of the simplest ways of achieving that is for each instance to maintain bi-directional pointers, similar to those you would find in a doubly-linked list. However, unlike a linked list, there is no need to expose these pointers outside of the class as the class can link and unlink all by itself, via the copy constructor and the assignment operator. All the functionality is encapsulated within the class so the lazy copy mechanism is completely transparent to the end user. The following implementation provides a brief demonstration of how the mechanism works. It is by no means a complete implementation as it can only handle one type of data, but it serves to demonstrate the key aspects of lazy copying. A more complete implementation would change the data to a template class, thus allowing any type of data to be lazy copied. The output shows that while each instance of the object occupies separate memory locations, the data they contain is initially shared. We then manipulate the objects to show that deep copying is occurring when it is required, and that destroying a share doesn't affect any remaining shares. If you strip away the trace code in the main function you will see that the lazy copy mechanism is completely transparent; you need never know it exists as it is fully encapsulated within the Object class itself. // Demonstration of a lazy copy mechanism // Copyright ©PCForrest, 2012 #include <iostream> using namespace std; // Example data container. class Data { friend ostream& operator<<(ostream& os, const Data& data); public: inline ~Data(){delete(m_num);} inline Data():m_num(new int(0)){} inline Data(const int num):m_num(new int(num)){} inline Data(const Data& data):m_num(new int(*data.m_num)){} inline Data& operator=(const Data& data){*m_num=*data.m_num; return(*this);} inline Data& operator=(const int num){*m_num=num; return(*this);} inline bool operator==(const Data& data){return(*m_num==*data.m_num);} inline bool operator!=(const Data& data){return(*m_num!=*data.m_num);} inline int operator+(const Data& data){return(*m_num+*data.m_num);} inline int operator+(const int num){return(*m_num+num);} inline Data& operator+=(const Data& data){*m_num+=*data.m_num; return(*this);} inline Data& operator+=(const int num){*m_num+=num; return(*this);} inline int GetNum()const{return(*m_num);} inline void SetNum(const int num){*m_num=num;} private: int * m_num; }; // Friend function ostream& operator<<(ostream& os, const Data& data) { os<<"Data:0x"<<&data<<" ("<<*data.m_num<<")"; return(os); } // Lazy copy class. class Object { friend ostream& operator<<(ostream& os, const Object& object); public: inline Object():m_nextshare(NULL),m_prevshare(NULL),m_data(new Data(0)){} inline Object(const Object& object):m_prevshare(&object.LocateLastShare()),m_nextshare(NULL),m_data(object.m_data){m_prevshare->m_nextshare=this;} inline ~Object(){if(IsShared())UnlinkShare();else delete( m_data ); m_data = NULL;} Object& operator=(const Object& object); Object& operator+=(const Object& object); inline Data GetData()const{return( *m_data);} void SetData(const Data& data); private: inline bool IsShared()const{return(m_prevshare!=NULL m_nextshare!=NULL);} Object& LocateLastShare()const; Object* LocateShare(const Object & object)const; void UnlinkShare(); mutable Object * m_nextshare; mutable Object * m_prevshare; Data * m_data; }; // Friend function ostream& operator<<(ostream& os, const Object& object) { os<<"Object:0x"<<&object<<"\t"<<*object.m_data; return(os); } // Assign (implements shallow-copy) Object& Object::operator=(const Object& object) { if( &object != this && // Not a self-reference. !LocateShare(object) ) // Not already shared. { // Unlink or destroy data. if( IsShared() ) UnlinkShare(); else if( m_data ) delete( m_data ); // Shallow-copy. m_data = object.m_data; // Link to new shares. m_prevshare = &object.LocateLastShare(); m_prevshare->m_nextshare = this; } return(*this); } // Add/assign (implements deep-copy) Object& Object::operator+=(const Object& object) { if( IsShared() ) { UnlinkShare(); m_data = new Data( *m_data + *object.m_data ); } else *m_data += *object.m_data; return( *this ); } // Returns a reference to the last shared instance of this instance. Object& Object::LocateLastShare()const { Object* p=(Object*)this; while(p && p->m_nextshare) p=p->m_nextshare; return(*p); } // Returns a pointer to the given object if it is amongst the shared instances // of this instance. Returns NULL if the object is this instance or is not shared. Object* Object::LocateShare(const Object& object)const { // Search previous instances first. Object* p=m_prevshare; while( p && p!=&object) p=p->m_prevshare; if(!p) { // Not found, search next instances: p = m_nextshare; while( p && p!=&object) p=p->m_nextshare; } return(p); } // Unlinks this object from its shared instances. void Object::UnlinkShare() { // Update the links on either side first. if(m_nextshare) m_nextshare->m_prevshare=m_prevshare; if(m_prevshare) m_prevshare->m_nextshare=m_nextshare; m_nextshare=NULL; m_prevshare=NULL; } // Mutator. Implements deep copy if incoming data differs. void Object::SetData(const Data& data) { if( *m_data != data ) { if( IsShared() ) { UnlinkShare(); m_data = new Data(data); } else *m_data = data; } } // Demonstration program: int main() { Object a; a.SetData( 5 ); Object b = a; // Assign (lazy copy) Object* c = new Object(b); // Copy construct (lazy copy) cout<<"Original memory:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; b += a; // Deep copy. cout<<"After mutating b:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; delete(c); cout<<"After destroying c:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<endl; // Instantiate a new, unshared instance c = new Object(); cout<<"After instantiating c as new:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; // Assign b to c *c = b; cout<<"After reassigning c:"<<endl; cout<<"a\t"<<a<<endl; cout<<"b\t"<<b<<endl; cout<<"c\t"<<*c<<endl; cout<<endl; return(0); } Output: Original memory: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x003577B8 (5) c Object:0x00211F58 Data:0x003577B8 (5) After mutating b: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) c Object:0x00211F58 Data:0x003577B8 (5) After destroying c: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) After instantiating c as new: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) c Object:0x00211F58 Data:0x003578A8 (0) After reassigning c: a Object:0x001FFA20 Data:0x003577B8 (5) b Object:0x001FFA0C Data:0x00357818 (10) c Object:0x00211F58 Data:0x00357818 (10)
What is the use of combining data and functions in c plus plus?
In procedural programming, we define a set of functions that will act upon a given set of data. However, the data and the functions that affect that data are actually quite separate, which can leave the data "exposed"; functions are free to alter the data without any regard to the actual type of data or what it represents. Ownership of the data is ambiguous at best. Without safeguards, the data could be invalidated at any time. In structured programming we can organise the data and procedures in a more systematic fashion. However the data still required safeguards to maintain its validity. With object-oriented programming we can combine small sets of data with the methods that can specifically modify that data into a single entity; an object. Each object is solely responsible for its own data, which can now be safely hidden from procedures that have no business accessing that data. Interfaces to the data can be designed such that the underlying data remains in a valid state at all times and access to the data and the functions that can modify the data can be strictly controlled by the object itself. Users of objects do not need to know how an object physically stores its data, nor how it manipulates that data -- their only concern is to store the data, retrieve the data, and to modify the data. All of this is achieved by the interface exposed by the object. They need not concern themselves with the underlying implementation of that object, only that it does what it was intended to do in a highly predictable manner, nothing more and nothing less. As with structured programming, complex data structures can be created by combining existing objects to create new objects. But since every object takes care of its own data, highly complex and robust structures that would otherwise be extremely difficult to implement become feasible. An object that contains other objects needn't be concerned with how those objects actually work. For instance, a list object is not concerned with the type of data it can store, its only concern is to manage the node objects in the list, nothing more and nothing less. Similarly, the individual node objects have no concern for the type of data they contain, only that they have data the user can retrieve. By delegating jobs to the objects that actually know how to implement the work, the risk of invalidating data is greatly reduced.
What does RDO stand for?
remote data object
What are the disadvantages of remote data object?
Some disadvantages of remote data objects include potential for slower data retrieval due to network latency, increased security risks when transmitting data over networks, and the potential for data inconsistency if multiple clients are accessing and modifying the same object concurrently.
What is the process of gathering and analyzing information about an object without physically being touch with the object?
Remote sensing is the process of gathering and analyzing information without being in physical contact with it.
Gathering and analyzing info about an object without physically being in touch with the object?
This process is known as remote sensing, where instruments like satellites or drones are used to collect data from a distance using sensors. The data captured can be analyzed to gain insights about the object's characteristics, such as temperature, composition, or movement. Remote sensing is widely used in fields like environmental monitoring, agriculture, and urban planning.
What is remote data storage?
Remote Data Storage is a service where your data is backed up at a location outside of your location. Many companies offer this as a secure backup of data and software in the event of fire or damage. Remote data storage is when you keep computer files at an offsite location. Usually services that offer remote data storage have large server banks that will store your data securely for a fee.
What is remote data?
A remote data object is one that would be located on a different "node". For instance, a node the hardware where the operating system resides, which houses a database. Nodes have IP addresses and names. Say that the main database resided on node "Payroll" (10.128.132.10). Via a database link, an object from another node "Accounting" (10.128.142.11) is referenced. An example of this could be a view which pulls data from a table in the Payroll database and joins it to a table in the Accounting database and the view shows data from both nodes.
What is a remote storage?
Remote Data Storage is a service where your data is backed up at a location outside of your location. Many companies offer this as a secure backup of data and software in the event of fire or damage. Remote data storage is when you keep computer files at an offsite location. Usually services that offer remote data storage have large server banks that will store your data securely for a fee.
What is remote sensing and what are some ways mapping data be gathered remotely?
Remote sensing is the process of collecting data about an object or area from a distance, typically using satellites or aircraft. Some ways mapping data can be gathered remotely include satellite imagery, LiDAR (Light Detection and Ranging) technology, aerial photography, and drones equipped with sensors.
What does scientists do to collect data remotely?
Remote sensing is the small- or large-scaleacquisition of information of an object or phenomenon, by the use of either recording or real-time sensing device(s) to collect data in inaccessible areas etc.
What are some of the benefits of remote data storage?
Remote storage data is useful in the event of your computer crashing, becoming infected or possible externally damaged unexpectedly. Having remote data storage ensures your important files and documents are safe.
What is adodc?
Acitex data object database
What are devices for remote data backups?
There are a number of devices for remote data backups. These include the IDSBox and the IDSbox Mini. Websites such as PC Pro offer more information on remote backup devices.
