igesline.h (r6227/r5847)

/* Copyright (C) 2015 David Eller <david@larosterna.com>
 * 
 * Commercial License Usage
 * Licensees holding valid commercial licenses may use this file in accordance
 * with the terms contained in their respective non-exclusive license agreement.
 * For further information contact david@larosterna.com .
 *
 * GNU General Public License Usage
 * Alternatively, this file may be used under the terms of the GNU General
 * Public License version 3.0 as published by the Free Software Foundation and
 * appearing in the file gpl.txt included in the packaging of this file.
 */
 
#ifndef SURF_IGESLINE_H
#define SURF_IGESLINE_H

#include <genua/defines.h>

#include <cstring>
#include <iostream>
#include <cstdio>
#include <cassert>

inline void iges_insert(char a[], int len, int x)
{
  int neg = 0;
  if (x == 0) {
    a[len-1] = '0';
    return;
  } else if (x < 0) {
    neg = 1;
    x = -x;
  }

  int i = len-1;
  while (x != 0 and i >= 0) {
    int d = x%10;
    a[i] = '0' + d;
    x /= 10;
    --i;
  }

  if (neg and i >= 0)
    a[i] = '-';
}

inline void iges_insert(char a[], int len, int x, char pad)
{
  for (int k=0; k<len; ++k)
    a[k] = pad;
  iges_insert(a, len, x);
}

class IgesLine
{
  public:
      
    IgesLine() {erase();}
    
    void erase() {
      memset(ms, ' ', 80);
      ms[80] = '\0';
    }
    
    const char *content() const {return ms;}
    
    char *content() {return ms;}
    
    uint copyContent(uint n, const char *src) {
      int nc = std::min(72u, n);
      memcpy(ms, src, nc);
      return nc;
    }
    
    void fixedNumber(int i, int v) {
      assert(i < 9);
      iges_insert(&ms[8*i], 8, v, ' ');
    } 

    int fixedInteger(int i) const {
      assert(i < 9);
      const char *pos = &ms[8*i];
      if (pos[7] == ' ')
        return 0;
      char *tail;
      int v;
      v = strtol(pos, &tail, 10);
      assert(pos != tail);
      return v;
    }
    
    void statusCode(uint blank, uint subswitch, uint useflag, uint hierarchy) {
      assert(blank < 100);
      assert(subswitch < 100);
      assert(useflag < 100);
      assert(hierarchy < 100);
      iges_insert(&ms[64], 4, 100*blank + subswitch, '0');
      iges_insert(&ms[68], 4, 100*useflag + hierarchy, '0');
    }
    
    void section(char sl) { 
      assert(sl == 'S' or sl == 'G' or sl == 'D' or sl == 'P' or sl == 'T');
      ms[72] = sl; 
    }

    char section() const {return ms[72];}
    
    void number(uint ln) {
      assert(ln < 9999999);
      iges_insert(&ms[73], 7, ln, ' ');
    }
    
    uint number() const {
      return atoi(&ms[73]);
    } 
    
    void write(std::ostream & os) const {
      // make sure that the the string is terminated
      char *pms = const_cast<char*>(ms);
      pms[80] = '\0';
      os << pms << std::endl;
    }
    
    void read(std::istream & is) {
      std::string line;
      std::getline(is, line);
      int n = std::min(line.length(), size_t(80));
      memcpy(ms, line.c_str(), n);
      ms[80] = '\0';
    }

  private:
    
    char ms[81];
};

typedef std::vector<IgesLine> IgesLineArray;

#endif