Home | History | Annotate | Download | only in ADT 
      1 //===- InMemoryStruct.h - Indirect Struct Access Smart Pointer --*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #ifndef LLVM_ADT_INMEMORYSTRUCT_H
     11 #define LLVM_ADT_INMEMORYSTRUCT_H
     12 
     13 #include <cassert>
     14 
     15 namespace llvm {
     16 
     17 /// \brief Helper object for abstracting access to an in-memory structure which
     18 /// may require some kind of temporary storage.
     19 ///
     20 /// This class is designed to be used for accessing file data structures which
     21 /// in the common case can be accessed from a direct pointer to a memory mapped
     22 /// object, but which in some cases may require indirect access to a temporary
     23 /// structure (which, for example, may have undergone endianness translation).
     24 template<typename T>
     25 class InMemoryStruct {
     26   typedef T value_type;
     27   typedef value_type &reference;
     28   typedef value_type *pointer;
     29   typedef const value_type &const_reference;
     30   typedef const value_type *const_pointer;
     31 
     32   /// \brief The smart pointer target.
     33   value_type *Target;
     34 
     35   /// \brief A temporary object which can be used as a target of the smart
     36   /// pointer.
     37   value_type Contents;
     38 
     39 private:
     40 
     41 public:
     42   InMemoryStruct() : Target(0) {}
     43   InMemoryStruct(reference Value) : Target(&Contents), Contents(Value) {}
     44   InMemoryStruct(pointer Value) : Target(Value) {}
     45   InMemoryStruct(const InMemoryStruct<T> &Value) { *this = Value; }
     46 
     47   void operator=(const InMemoryStruct<T> &Value) {
     48     if (Value.Target != &Value.Contents) {
     49       Target = Value.Target;
     50     } else {
     51       Target = &Contents;
     52       Contents = Value.Contents;
     53     }
     54   }
     55 
     56   const_reference operator*() const {
     57     assert(Target && "Cannot dereference null pointer");
     58     return *Target;
     59   }
     60   reference operator*() {
     61     assert(Target && "Cannot dereference null pointer");
     62     return *Target;
     63   }
     64 
     65   const_pointer operator->() const {
     66     return Target;
     67   }
     68   pointer operator->() {
     69     return Target;
     70   }
     71 
     72   operator bool() const { return Target != 0; }
     73 };
     74 
     75 }
     76 
     77 #endif
     78