Casarc.h

Go to the documentation of this file.

//# Casarc.h: Class to read the casa general resource files
//# Copyright (C) 2009
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id$

#ifndef CASA_CASARC_H
#define CASA_CASARC_H

#include <casacore/casa/aips.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string>
#include <list>
#include <map>

namespace casacore { //# NAMESPACE CASACORE - BEGIN

    class Casarc {

        friend class CasarcCleanup;

        public:

            typedef std::map<std::string,std::string>::const_iterator iterator;

            // return default casarc file, e.g. ~/.casarc
            static Casarc &instance( );

            // set and clear the default casarc path (to something other than ~/.casarc)
            static void setDefaultPath( const std::string &path );
            static void clearDefaultPath( );

            // return a casarc object attached to a particular file
            static Casarc &instance( const std::string &path );

            // return the list of rcfiles that have been loaded
            static const std::list<Casarc*> & list( );

            // adds the keyword->value mapping
            void put( const std::string &keyword, const std::string &value );

            // retrieves the mapping for keyword (or "" if the mapping is not defined)
            std::string get( const std::string &keyword );

            // retrieves the mapping for keyword in value (and returns true if the
            // mapping is defined or false otherwise)
            bool get( const std::string &keyword, std::string &value );

            size_t size( ) const;

            // path to the file that this Casarc mirrors...
            const std::string &path( ) const { return filename; }

            iterator begin( );
            iterator end( );

        private:

            class meta_entry_ {
            public:
                meta_entry_( off_t keys_, int keyl_, off_t vals_, int vall_, off_t times_, int timel_ ) : 
                                        key_offset_(keys_), key_len_(keyl_), 
                                        val_offset_(vals_), val_len_(vall_),
                                        time_offset_(times_), time_len_(timel_) { }

                off_t key_offset( ) const { return key_offset_; }
                int key_length( ) const { return key_len_; }

                off_t value_offset( ) const { return val_offset_; }
                int value_length( ) const { return val_len_; }

                off_t time_offset( ) const { return time_offset_; }
                int time_length( ) const { return time_len_; }

            private:
                off_t key_offset_;
                int key_len_;
                off_t val_offset_;
                int val_len_;
                off_t time_offset_;
                int time_len_;
            };

            char *mapped_file;
            off_t mapped_file_size;

            std::list<int> stale_fds;
            void close( int );

            std::list<pid_t> have_lock;

            enum lock_mode { READ, READ_WRITE, WRITE, APPEND };
            // returns a file descriptor or -1 on error...
            int lock( lock_mode mode );
            void unlock( int fd );

            void sync( );
            double current_modification_time( struct stat &buf );

            std::string filename;
            double timestamp;

            std::map<std::string,std::string> rcmap;
            // this is broken off separate from the rcmap to allow the
            // rcmap to be used for iteration by users of this class...
            std::map<std::string,meta_entry_> rcmetamap;

            void read_file( );

            ino_t inode;

            // singleton Casarcs, (inode->casarc)
            static std::map<ino_t,Casarc*> *rcfiles;
            static std::map<std::string,Casarc*> *filenames;
            static std::list<Casarc*> *rclist;
            static std::string *default_path;
            // path is the path to the .casarc (or .aipsrc file)
            Casarc( const std::string &path );
            static bool initialized;
            static void startup( );
            static void shutdown( );
            ~Casarc( ) { }
    };

    static class CasarcCleanup {
        public:
            CasarcCleanup( ) { creation_count += 1; }
            ~CasarcCleanup( ) { if ( --creation_count == 0 ) { Casarc::shutdown( ); } }
        private:
            static unsigned int creation_count;
    } local_cleanup_object;
  
} //# NAMESPACE CASACORE - END

#endif