primitive_attributes.h

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// Licensed 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.
//

// Interface for class primitive_attributes

#ifndef PRIMITIVE_ATTRIBUTES_H
#define PRIMITIVE_ATTRIBUTES_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef PRIMITIVE_TYPE_H
#include "SheafSystem/primitive_type.h"
#endif

namespace sheaf
{

template <typename T>
class block;
  
class SHEAF_DLL_SPEC primitive_attributes
{
public:

  static const primitive_attributes& prototype(pod_index_type xid);

  static primitive_type id(const std::string& xname);

  static primitive_type id(pod_index_type xid)
  {
    return prototype(xid).id();
  };

  static size_type size(pod_index_type xid)
  {
    return prototype(xid).size();
  };

  static size_type alignment(pod_index_type xid)
  {
    return prototype(xid).alignment();
  };

  static const std::string& name(pod_index_type xid)
  {
    return prototype(xid).name();
  };

  static const std::string& aliases(pod_index_type xid)
  {
    return prototype(xid).aliases();
  };

  static const std::string& hdf_type_name(pod_index_type xid)
  {
    return prototype(xid).hdf_type_name();
  };

  static int hdf_type(pod_index_type xid)
  {
    return prototype(xid).hdf_type();
  };

  static primitive_buffer_type default_value(pod_index_type xid)
  {
    return prototype(xid).default_value();
  };

  static primitive_descriptor descriptor(pod_index_type xid)
  {
    return prototype(xid); // Return invokes conversion function
  };

  // ===========================================================
  // CONSTRUCTORS
  // ===========================================================

  primitive_attributes();

  primitive_attributes(const primitive_attributes& xother);

  primitive_attributes(primitive_type xid);

  primitive_attributes(const void* x);

  primitive_attributes(const char* x);

  template <typename T>
  primitive_attributes(const T& x);

  primitive_attributes& operator=(const primitive_attributes&);

  ~primitive_attributes();


  // ===========================================================
  // ATTRIBUTES
  // ===========================================================

  primitive_type id() const
  {
    return _id;
  };

  size_type size() const
  {
    return _size;
  };

  size_type alignment() const
  {
    return _alignment;
  };

  const std::string& name() const
  {
    return *_name;
  };

  const std::string& aliases() const
  {
    return *_aliases;
  };

  const std::string& hdf_type_name() const
  {
    return *_hdf_type_name;
  };

  int hdf_type() const
  {
    return _hdf_type;
  };

  primitive_buffer_type default_value() const
  {
    return _default_value;
  };

  operator primitive_descriptor() const;

private:

  primitive_type _id;

  size_type _size;

  size_type _alignment;

  const std::string* _name;

  const std::string* _aliases;

  const std::string* _hdf_type_name;

  int _hdf_type;

  primitive_buffer_type _default_value;

  static block<primitive_attributes>& make_prototypes();
};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================
 
} // namespace sheaf

#endif // ifndef PRIMITIVE_ATTRIBUTES_H