Wrappers.h

Go to the documentation of this file.

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 5 -*- */

/*
 * Created by Daniel Aarno on Sun Oct Oct, 2004.
 * Copyright (c) 2004 by Daniel Aarno - <macbishop@users.sf.net>
 * M. Sc. in Electrical Engineering * http://www.e.kth.se/~e98_aar
 * 
 * All Rights Reserved
 * ATTRIBUTION ASSURANCE LICENSE (adapted from the original BSD license)
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the conditions below are met.
 * These conditions require a modest attribution to  (the
 * "Author"), who hopes that its promotional value may help justify the
 * thousands of dollars in otherwise billable time invested in writing
 * this and other freely available, open-source software.
 * 
 * 1. Redistributions of source code, in whole or part and with or without
 * modification (the "Code"), must prominently display this GPG-signed
 * text in verifiable form.
 * 2. Redistributions of the Code in binary form must be accompanied by
 * this GPG-signed text in any documentation and, each time the resulting
 * executable program or a program dependent thereon is launched, a
 * prominent display (e.g., splash screen or banner text) of the Author's
 * attribution information, which includes:
 * (a) Name ("Daniel Aarno"),
 * (b) Professional identification ("M. Sc. in Electrical Engineering"), and
 * (c) URL ("http://www.e.kth.se/~e98_aar").
 * 3. Neither the name nor any trademark of the Author may be used to
 * endorse or promote products derived from this software without specific
 * prior written permission.
 * 4. Users are entirely responsible, to the exclusion of the Author and
 * any other persons, for compliance with (1) regulations set by owners or
 * administrators of employed equipment, (2) licensing terms of any other
 * software, and (3) local regulations regarding use, including those
 * regarding import, export, and use of encryption software.
 * 
 * THIS FREE SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 * EVENT SHALL THE AUTHOR OR ANY CONTRIBUTOR BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * EFFECTS OF UNAUTHORIZED OR MALICIOUS NETWORK ACCESS;
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _WRAPPERS_
#define _WRAPPERS_

#include <stdio.h>

namespace WRAPPERS {
     class File {
          FILE* m_fp;
          
          void close(FILE* fp) const { if(fp) fclose(fp); }
     public:
          File(FILE* fp = 0) : m_fp(fp) {}

          File(const char* path, const char* mode) {
               m_fp = fopen(path, mode);
          }

          File(File &o) : m_fp(o.m_fp) { o.m_fp = 0; }
          
          ~File() { fclose(m_fp); m_fp = 0; }
          
          operator const FILE*() const { return m_fp; }

          FILE* get() { return m_fp; }
          
          const File& operator=(File &rhs) { 
               if(&rhs == this)
                    return *this;
               close(m_fp); 
               m_fp = rhs.m_fp; 
               rhs.m_fp = 0;  
               return *this;
          }
     };//File

     template<typename T> class auto_ary {
          T* m_ptr;

     public:
          explicit auto_ary(T* ptr=0) : m_ptr(ptr) {}

          auto_ary(auto_ary<T> &o) : m_ptr(o.m_ptr) { o.m_ptr = 0; }

          ~auto_ary() { delete[] m_ptr; m_ptr = 0; }
          
          auto_ary<T>& operator=(auto_ary<T> &rhs) {
               if(this == &rhs)
                    return *this;
               
               delete[] m_ptr;
               m_ptr = rhs.m_ptr;
               rhs.m_ptr = 0;
          }
          
          const T& operator[](int i) const { return m_ptr[i]; }

          T& operator[](int i) { return m_ptr[i]; }
          
          T* get() const { return m_ptr; }
     }; //auto_ary
} //namespace

#endif

---