PlyReader.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions 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.

#ifndef SURGSIM_DATASTRUCTURES_PLYREADER_H
#define SURGSIM_DATASTRUCTURES_PLYREADER_H

#include <string>
#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>

namespace SurgSim
{
namespace DataStructures
{

class PlyReaderDelegate;



class PlyReader
{
public:
    enum Type
    {
        TYPE_INVALID = 0,
        TYPE_CHAR,
        TYPE_SHORT,
        TYPE_INT,
        TYPE_UNSIGNED_CHAR,
        TYPE_UNSIGNED_SHORT,
        TYPE_UNSIGNED_INT,
        TYPE_FLOAT,
        TYPE_DOUBLE,
        TYPE_COUNT
    };

    typedef std::function<void* (const std::string&, size_t)> StartElementCallbackType;

    typedef std::function<void (const std::string&)> StandardCallbackType;

    explicit PlyReader(const std::string& filename);

    virtual ~PlyReader();

    bool isValid() const;

    bool requestElement(const std::string& elementName,
                        std::function<void* (const std::string&, size_t)> startElementCallback,
                        std::function<void (const std::string&)> processElementCallback,
                        std::function<void (const std::string&)> endElementCallback);

    bool requestScalarProperty(const std::string& elementName, const std::string& propertyName,
        int dataType, int dataOffset);

    bool requestListProperty(const std::string& elementName,
                             const std::string& propertyName,
                             int dataType, int dataOffset,
                             int countType, int countOffset);

    bool hasElement(const std::string& elementName) const;

    bool hasProperty(const std::string& elementName, const std::string& propertyName) const;

    bool isScalar(const std::string& elementName, const std::string& propertyName) const;

    bool parseWithDelegate(std::shared_ptr<PlyReaderDelegate> delegate);

    void setStartParseFileCallback(std::function<void (void)> startParseFileCallback);

    void setEndParseFileCallback(std::function<void (void)> endParseFileCallback);

    bool setDelegate(std::shared_ptr<PlyReaderDelegate> delegate);

    void parseFile();

private:
    friend class PlyReaderTests;

    bool requestProperty(const std::string& elementName,
                         const std::string& propertyName,
                         int dataType, int dataOffset,
                         int countType, int countOffset);

    std::string m_filename;

    struct PropertyInfo
    {
        std::string propertyName; 
        int dataType = -1; 
        int dataOffset = -1; 
        int countType = -1; 
        int countOffset = -1; 
    };

    struct ElementInfo
    {
        std::string name; 
        StartElementCallbackType startElementCallback; 
        StandardCallbackType processElementCallback; 
        StandardCallbackType endElementCallback; 
        std::vector<PropertyInfo> requestedProperties; 
    };

    std::unordered_map<std::string, ElementInfo> m_requestedElements;

    struct Data;
    std::unique_ptr<Data> m_data;

    std::shared_ptr<PlyReaderDelegate> m_delegate;

    std::function<void(void)> m_startParseFileCallback;

    std::function<void(void)> m_endParseFileCallback;
};

} // DataStructures
} // SurgSim

#endif // SURGSIM_DATASTRUCTURES_PLYREADER_H