src/main/decaf/lang/System.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _DECAF_LANG_SYSTEM_H_
#define _DECAF_LANG_SYSTEM_H_

#include <decaf/util/Config.h>
#include <decaf/util/Map.h>
#include <decaf/util/Properties.h>
#include <decaf/lang/Exception.h>
#include <decaf/lang/exceptions/NullPointerException.h>
#include <decaf/internal/AprPool.h>
#include <string>

namespace decaf{
namespace lang{

    class Runtime;
    class SystemData;

    class DECAF_API System {
    private:

        static SystemData* sys;

    protected:

        System();

    public:

        virtual ~System() {}

    public:  // Static Methods

        static void arraycopy( const char* src, std::size_t srcPos,
                               char* dest, std::size_t destPos, std::size_t length );

        static void arraycopy( const unsigned char* src, std::size_t srcPos,
                               unsigned char* dest, std::size_t destPos, std::size_t length );

        static void arraycopy( const short* src, std::size_t srcPos,
                               short* dest, std::size_t destPos, std::size_t length );

        static void arraycopy( const int* src, std::size_t srcPos,
                               int* dest, std::size_t destPos, std::size_t length );

        static void arraycopy( const long long* src, std::size_t srcPos,
                               long long* dest, std::size_t destPos, std::size_t length );

        static void arraycopy( const float* src, std::size_t srcPos,
                               float* dest, std::size_t destPos, std::size_t length );

        static void arraycopy( const double* src, std::size_t srcPos,
                               double* dest, std::size_t destPos, std::size_t length );

        template< typename E >
        static void arraycopy( const E* src, std::size_t srcPos,
                               E* dest, std::size_t destPos, std::size_t length ) {

            if( src == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "Given Source Pointer was null." );
            }

            if( src == NULL ) {
                throw decaf::lang::exceptions::NullPointerException(
                    __FILE__, __LINE__, "Given Source Pointer was null." );
            }

            for( std::size_t i = 0; i < length; ++i ) {
                dest[destPos+i] = src[srcPos+i];
            }
        }

        static const util::Map<std::string, std::string>& getenv();

        static std::string getenv( const std::string& name );

        static void unsetenv( const std::string& name );

        static void setenv( const std::string& name, const std::string& value );

        static long long currentTimeMillis();

        static long long nanoTime();

        static int availableProcessors();

        static decaf::util::Properties& getProperties();

        static std::string getProperty( const std::string& key );

        static std::string getProperty( const std::string& key, const std::string& defaultValue );

        static std::string setProperty( const std::string& key, const std::string& value );

        static std::string clearProperty( const std::string& key );

    private:

        static std::vector< std::string > getEnvArray();

        static internal::AprPool& getAprPool();

    private:

        friend class decaf::lang::Runtime;

        static void initSystem( int argc, char **argv );
        static void shutdownSystem();

    };

}}

#endif /*_DECAF_LANG_SYSTEM_H_*/